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

    /*
    public partial class dbModel2 : DbContext
    {
        public dbModel2()
            : base("name=dbModel2")
        {
        }

        public virtual DbSet<C__Base_DriveInfo_WillDel> C__Base_DriveInfo_WillDel { get; set; }
        public virtual DbSet<C_WillDel_Base_Consignor_Address> C_WillDel_Base_Consignor_Address { get; set; }
        public virtual DbSet<Adjustment_Client_Batch> Adjustment_Client_Batch { get; set; }
        public virtual DbSet<Adjustment_Client_BatchList> Adjustment_Client_BatchList { get; set; }
        public virtual DbSet<Adjustment_Provider_Batch> Adjustment_Provider_Batch { get; set; }
        public virtual DbSet<Adjustment_Provider_BatchList> Adjustment_Provider_BatchList { get; set; }
        public virtual DbSet<AliExpress_Catalog_Relation> AliExpress_Catalog_Relation { get; set; }
        public virtual DbSet<AliExpress_CatalogAttribute> AliExpress_CatalogAttribute { get; set; }
        public virtual DbSet<AliExpress_CatalogAttributeValue> AliExpress_CatalogAttributeValue { get; set; }
        public virtual DbSet<AliExpress_Client_Relation> AliExpress_Client_Relation { get; set; }
        public virtual DbSet<AliExpress_Express_Relation> AliExpress_Express_Relation { get; set; }
        public virtual DbSet<AliExpress_FreightTemplate> AliExpress_FreightTemplate { get; set; }
        public virtual DbSet<AliExpress_Logistics> AliExpress_Logistics { get; set; }
        public virtual DbSet<AliExpress_Order_Fulfillment> AliExpress_Order_Fulfillment { get; set; }
        public virtual DbSet<AliExpress_OrderMsg> AliExpress_OrderMsg { get; set; }
        public virtual DbSet<AliExpress_OrderStatus_Relation> AliExpress_OrderStatus_Relation { get; set; }
        public virtual DbSet<AliExpress_Picture_Relation> AliExpress_Picture_Relation { get; set; }
        public virtual DbSet<AliExpress_Product> AliExpress_Product { get; set; }
        public virtual DbSet<AliExpress_Product_Variation> AliExpress_Product_Variation { get; set; }
        public virtual DbSet<AliExpress_Product_VariationSet> AliExpress_Product_VariationSet { get; set; }
        public virtual DbSet<AliExpress_Product_VariationValue> AliExpress_Product_VariationValue { get; set; }
        public virtual DbSet<AliExpress_SaleOrder> AliExpress_SaleOrder { get; set; }
        public virtual DbSet<AliExpress_SaleOrderList> AliExpress_SaleOrderList { get; set; }
        public virtual DbSet<AliExpress_StoreInfo> AliExpress_StoreInfo { get; set; }
        public virtual DbSet<Amazon_AttributeItem> Amazon_AttributeItem { get; set; }
        public virtual DbSet<Amazon_AttributeItemValue> Amazon_AttributeItemValue { get; set; }
        public virtual DbSet<Amazon_Catalog_Relation> Amazon_Catalog_Relation { get; set; }
        public virtual DbSet<Amazon_Client_Relation> Amazon_Client_Relation { get; set; }
        public virtual DbSet<Amazon_Feedback> Amazon_Feedback { get; set; }
        public virtual DbSet<Amazon_Order_Acknowledgement> Amazon_Order_Acknowledgement { get; set; }
        public virtual DbSet<Amazon_Order_AcknowledgementList> Amazon_Order_AcknowledgementList { get; set; }
        public virtual DbSet<Amazon_Order_Fulfillment> Amazon_Order_Fulfillment { get; set; }
        public virtual DbSet<Amazon_Order_FulfillmentList> Amazon_Order_FulfillmentList { get; set; }
        public virtual DbSet<Amazon_OrderStatus_Relation> Amazon_OrderStatus_Relation { get; set; }
        public virtual DbSet<Amazon_Product> Amazon_Product { get; set; }
        public virtual DbSet<Amazon_Product_ImageRelation> Amazon_Product_ImageRelation { get; set; }
        public virtual DbSet<Amazon_Product_ItemValue> Amazon_Product_ItemValue { get; set; }
        public virtual DbSet<Amazon_ProductBigType> Amazon_ProductBigType { get; set; }
        public virtual DbSet<Amazon_ProductType> Amazon_ProductType { get; set; }
        public virtual DbSet<Amazon_ProductType_Attribute_Relation> Amazon_ProductType_Attribute_Relation { get; set; }
        public virtual DbSet<Amazon_SaleOrder> Amazon_SaleOrder { get; set; }
        public virtual DbSet<Amazon_SaleOrderList> Amazon_SaleOrderList { get; set; }
        public virtual DbSet<Amazon_SpecValueRelation> Amazon_SpecValueRelation { get; set; }
        public virtual DbSet<Amazon_StoreInfo> Amazon_StoreInfo { get; set; }
        public virtual DbSet<API_PurchaseOrder_Feedback> API_PurchaseOrder_Feedback { get; set; }
        public virtual DbSet<API_PurchaseOrder_FeedbackList> API_PurchaseOrder_FeedbackList { get; set; }
        public virtual DbSet<API_PurchaseOrder_State> API_PurchaseOrder_State { get; set; }
        public virtual DbSet<API_SaleOrder_Feedback> API_SaleOrder_Feedback { get; set; }
        public virtual DbSet<API_SaleOrder_FeedbackList> API_SaleOrder_FeedbackList { get; set; }
        public virtual DbSet<API_SaleOrder_State> API_SaleOrder_State { get; set; }
        public virtual DbSet<App_Address> App_Address { get; set; }
        public virtual DbSet<App_Feedback> App_Feedback { get; set; }
        public virtual DbSet<App_GoodsView> App_GoodsView { get; set; }
        public virtual DbSet<App_ProductApply> App_ProductApply { get; set; }
        public virtual DbSet<Base_AllotPosition> Base_AllotPosition { get; set; }
        public virtual DbSet<Base_Brand> Base_Brand { get; set; }
        public virtual DbSet<Base_Carrier> Base_Carrier { get; set; }
        public virtual DbSet<Base_City> Base_City { get; set; }
        public virtual DbSet<Base_City_PostCode> Base_City_PostCode { get; set; }
        public virtual DbSet<Base_Client> Base_Client { get; set; }
        public virtual DbSet<Base_Consignor> Base_Consignor { get; set; }
        public virtual DbSet<Base_ConsignorAddress> Base_ConsignorAddress { get; set; }
        public virtual DbSet<Base_ConsignorContract> Base_ConsignorContract { get; set; }
        public virtual DbSet<Base_ConsignorList> Base_ConsignorList { get; set; }
        public virtual DbSet<Base_ConsignorStore> Base_ConsignorStore { get; set; }
        public virtual DbSet<Base_ConsignorStoreAddress> Base_ConsignorStoreAddress { get; set; }
        public virtual DbSet<Base_Country> Base_Country { get; set; }
        public virtual DbSet<Base_CountryExpress_Relation> Base_CountryExpress_Relation { get; set; }
        public virtual DbSet<Base_CountryStorage_Relation> Base_CountryStorage_Relation { get; set; }
        public virtual DbSet<Base_Destination> Base_Destination { get; set; }
        public virtual DbSet<Base_Driver> Base_Driver { get; set; }
        public virtual DbSet<Base_DriverContract> Base_DriverContract { get; set; }
        public virtual DbSet<Base_DriverVehicle> Base_DriverVehicle { get; set; }
        public virtual DbSet<Base_EmptyEquipment> Base_EmptyEquipment { get; set; }
        public virtual DbSet<Base_EmptyEquipmentList> Base_EmptyEquipmentList { get; set; }
        public virtual DbSet<Base_EmptyEquipmentReturn> Base_EmptyEquipmentReturn { get; set; }
        public virtual DbSet<Base_EmptyEquipmentReturnList> Base_EmptyEquipmentReturnList { get; set; }
        public virtual DbSet<Base_EmptyPlateTransfer> Base_EmptyPlateTransfer { get; set; }
        public virtual DbSet<Base_Equipment> Base_Equipment { get; set; }
        public virtual DbSet<Base_ExpressCorp> Base_ExpressCorp { get; set; }
        public virtual DbSet<Base_ExpressCorp_Regular> Base_ExpressCorp_Regular { get; set; }
        public virtual DbSet<Base_ExpressDeclaredValue> Base_ExpressDeclaredValue { get; set; }
        public virtual DbSet<Base_ExpressSpareCode> Base_ExpressSpareCode { get; set; }
        public virtual DbSet<Base_Forklift> Base_Forklift { get; set; }
        public virtual DbSet<Base_FreightDiscount> Base_FreightDiscount { get; set; }
        public virtual DbSet<Base_FreightPartition> Base_FreightPartition { get; set; }
        public virtual DbSet<Base_FreightPrice> Base_FreightPrice { get; set; }
        public virtual DbSet<Base_FreightTemplate> Base_FreightTemplate { get; set; }
        public virtual DbSet<Base_ImageConfig> Base_ImageConfig { get; set; }
        public virtual DbSet<Base_LightPosition> Base_LightPosition { get; set; }
        public virtual DbSet<Base_LightSortInfo> Base_LightSortInfo { get; set; }
        public virtual DbSet<Base_Order_Statistics> Base_Order_Statistics { get; set; }
        public virtual DbSet<Base_Park> Base_Park { get; set; }
        public virtual DbSet<Base_Plate> Base_Plate { get; set; }
        public virtual DbSet<Base_PlateType> Base_PlateType { get; set; }
        public virtual DbSet<Base_Platform> Base_Platform { get; set; }
        public virtual DbSet<Base_Port> Base_Port { get; set; }
        public virtual DbSet<Base_Position> Base_Position { get; set; }
        public virtual DbSet<Base_PositionPrint> Base_PositionPrint { get; set; }
        public virtual DbSet<Base_PostCode> Base_PostCode { get; set; }
        public virtual DbSet<Base_PrintTemplate> Base_PrintTemplate { get; set; }
        public virtual DbSet<Base_ProductFAQ> Base_ProductFAQ { get; set; }
        public virtual DbSet<Base_ProductFAQType> Base_ProductFAQType { get; set; }
        public virtual DbSet<Base_ProductInfo> Base_ProductInfo { get; set; }
        public virtual DbSet<Base_ProductInfo_FactValue> Base_ProductInfo_FactValue { get; set; }
        public virtual DbSet<Base_ProductInfo_Image> Base_ProductInfo_Image { get; set; }
        public virtual DbSet<Base_ProductInfo_Label> Base_ProductInfo_Label { get; set; }
        public virtual DbSet<Base_ProductInfo_SpecRelation> Base_ProductInfo_SpecRelation { get; set; }
        public virtual DbSet<Base_ProductInfo_SpecValue> Base_ProductInfo_SpecValue { get; set; }
        public virtual DbSet<Base_ProductInfo_SpecValueRelation> Base_ProductInfo_SpecValueRelation { get; set; }
        public virtual DbSet<Base_ProductInfo_Storage> Base_ProductInfo_Storage { get; set; }
        public virtual DbSet<Base_ProductInfoHistory> Base_ProductInfoHistory { get; set; }
        public virtual DbSet<Base_ProductionLine> Base_ProductionLine { get; set; }
        public virtual DbSet<Base_ProductPlaceHolder> Base_ProductPlaceHolder { get; set; }
        public virtual DbSet<Base_ProductPlaceHolder_Bak> Base_ProductPlaceHolder_Bak { get; set; }
        public virtual DbSet<Base_ProductPosition> Base_ProductPosition { get; set; }
        public virtual DbSet<Base_ProductPosition_Record> Base_ProductPosition_Record { get; set; }
        public virtual DbSet<Base_ProductPositionHistory> Base_ProductPositionHistory { get; set; }
        public virtual DbSet<Base_ProductPurchasePrice> Base_ProductPurchasePrice { get; set; }
        public virtual DbSet<Base_ProductSalePrice> Base_ProductSalePrice { get; set; }
        public virtual DbSet<Base_ProductSet> Base_ProductSet { get; set; }
        public virtual DbSet<Base_ProductSetList> Base_ProductSetList { get; set; }
        public virtual DbSet<Base_ProductType> Base_ProductType { get; set; }
        public virtual DbSet<Base_ProductType_Specification> Base_ProductType_Specification { get; set; }
        public virtual DbSet<Base_ProductType_SpecValue> Base_ProductType_SpecValue { get; set; }
        public virtual DbSet<Base_Provider> Base_Provider { get; set; }
        public virtual DbSet<Base_ProviderContract> Base_ProviderContract { get; set; }
        public virtual DbSet<Base_ProviderStep> Base_ProviderStep { get; set; }
        public virtual DbSet<Base_ProviderUser> Base_ProviderUser { get; set; }
        public virtual DbSet<Base_PublishTypeHistory> Base_PublishTypeHistory { get; set; }
        public virtual DbSet<Base_Region> Base_Region { get; set; }
        public virtual DbSet<Base_RegionList> Base_RegionList { get; set; }
        public virtual DbSet<Base_ShelveRegular> Base_ShelveRegular { get; set; }
        public virtual DbSet<Base_Sms> Base_Sms { get; set; }
        public virtual DbSet<Base_SortingCloutReturn> Base_SortingCloutReturn { get; set; }
        public virtual DbSet<Base_SortingCloutReturnList> Base_SortingCloutReturnList { get; set; }
        public virtual DbSet<Base_Specification> Base_Specification { get; set; }
        public virtual DbSet<Base_SpecificationValue> Base_SpecificationValue { get; set; }
        public virtual DbSet<Base_Staff> Base_Staff { get; set; }
        public virtual DbSet<Base_StationInfo> Base_StationInfo { get; set; }
        public virtual DbSet<Base_StationRegion> Base_StationRegion { get; set; }
        public virtual DbSet<Base_Storage> Base_Storage { get; set; }
        public virtual DbSet<Base_Storage_PositionTypeSortRegular> Base_Storage_PositionTypeSortRegular { get; set; }
        public virtual DbSet<Base_Storage_Region> Base_Storage_Region { get; set; }
        public virtual DbSet<Base_Storage_Regular> Base_Storage_Regular { get; set; }
        public virtual DbSet<Base_StorageArea> Base_StorageArea { get; set; }
        public virtual DbSet<Base_StorageDataClass> Base_StorageDataClass { get; set; }
        public virtual DbSet<Base_StorageImage> Base_StorageImage { get; set; }
        public virtual DbSet<Base_StorageLease> Base_StorageLease { get; set; }
        public virtual DbSet<Base_StorageShelve> Base_StorageShelve { get; set; }
        public virtual DbSet<Base_StorageTemperature> Base_StorageTemperature { get; set; }
        public virtual DbSet<Base_StorageWarnRegular> Base_StorageWarnRegular { get; set; }
        public virtual DbSet<Base_TruckFee> Base_TruckFee { get; set; }
        public virtual DbSet<Base_TruckInfo> Base_TruckInfo { get; set; }
        public virtual DbSet<Base_Vehicle> Base_Vehicle { get; set; }
        public virtual DbSet<Base_VehicleGroup> Base_VehicleGroup { get; set; }
        public virtual DbSet<CIQ_HZ_ApproveResult> CIQ_HZ_ApproveResult { get; set; }
        public virtual DbSet<CIQ_HZ_ApproveResultCode> CIQ_HZ_ApproveResultCode { get; set; }
        public virtual DbSet<CIQ_HZ_BasicInfo> CIQ_HZ_BasicInfo { get; set; }
        public virtual DbSet<CIQ_HZ_ContrastResult> CIQ_HZ_ContrastResult { get; set; }
        public virtual DbSet<CIQ_HZ_ContrastResultList> CIQ_HZ_ContrastResultList { get; set; }
        public virtual DbSet<CIQ_HZ_InFact> CIQ_HZ_InFact { get; set; }
        public virtual DbSet<CIQ_HZ_InFactList> CIQ_HZ_InFactList { get; set; }
        public virtual DbSet<CIQ_HZ_InOrder> CIQ_HZ_InOrder { get; set; }
        public virtual DbSet<CIQ_HZ_InOrderList> CIQ_HZ_InOrderList { get; set; }
        public virtual DbSet<CIQ_HZ_InOutContrast> CIQ_HZ_InOutContrast { get; set; }
        public virtual DbSet<CIQ_HZ_InOutContrastList> CIQ_HZ_InOutContrastList { get; set; }
        public virtual DbSet<CIQ_HZ_Merge> CIQ_HZ_Merge { get; set; }
        public virtual DbSet<CIQ_HZ_OutInOrder> CIQ_HZ_OutInOrder { get; set; }
        public virtual DbSet<CIQ_HZ_OutInOrderList> CIQ_HZ_OutInOrderList { get; set; }
        public virtual DbSet<CIQ_HZ_ReceiptDetail> CIQ_HZ_ReceiptDetail { get; set; }
        public virtual DbSet<CIQ_HZ_ReceiptInfo> CIQ_HZ_ReceiptInfo { get; set; }
        public virtual DbSet<CIQ_HZ_StockDelete> CIQ_HZ_StockDelete { get; set; }
        public virtual DbSet<CIQ_HZ_StockDeleteList> CIQ_HZ_StockDeleteList { get; set; }
        public virtual DbSet<CIQ_HZ_StockDeleteResult> CIQ_HZ_StockDeleteResult { get; set; }
        public virtual DbSet<CIQ_HZ_StockDeleteResultList> CIQ_HZ_StockDeleteResultList { get; set; }
        public virtual DbSet<CIQ_HZ_StorageInfo> CIQ_HZ_StorageInfo { get; set; }
        public virtual DbSet<CIQ_HZ_StorageInfoList> CIQ_HZ_StorageInfoList { get; set; }
        public virtual DbSet<CIQ_HZ_Verify> CIQ_HZ_Verify { get; set; }
        public virtual DbSet<CIQ_ImportPay> CIQ_ImportPay { get; set; }
        public virtual DbSet<CIQ_Info> CIQ_Info { get; set; }
        public virtual DbSet<CIQ_NB_Consignor> CIQ_NB_Consignor { get; set; }
        public virtual DbSet<CIQ_NB_ExpressCorp> CIQ_NB_ExpressCorp { get; set; }
        public virtual DbSet<CIQ_NB_NoFeedback> CIQ_NB_NoFeedback { get; set; }
        public virtual DbSet<CIQ_NB_OrderCancel> CIQ_NB_OrderCancel { get; set; }
        public virtual DbSet<CIQ_NB_OutFeedback> CIQ_NB_OutFeedback { get; set; }
        public virtual DbSet<CIQ_NB_OutFeedbackList> CIQ_NB_OutFeedbackList { get; set; }
        public virtual DbSet<CIQ_NB_ProductInfo> CIQ_NB_ProductInfo { get; set; }
        public virtual DbSet<CIQ_NB_ProductInfo_Storage> CIQ_NB_ProductInfo_Storage { get; set; }
        public virtual DbSet<CIQ_NB_PurchaseOrder> CIQ_NB_PurchaseOrder { get; set; }
        public virtual DbSet<CIQ_NB_PurchaseOrder_Up> CIQ_NB_PurchaseOrder_Up { get; set; }
        public virtual DbSet<CIQ_NB_PurchaseOrder_UpList> CIQ_NB_PurchaseOrder_UpList { get; set; }
        public virtual DbSet<CIQ_NB_PurchaseOrderCancel> CIQ_NB_PurchaseOrderCancel { get; set; }
        public virtual DbSet<CIQ_NB_PurchaseOrderList> CIQ_NB_PurchaseOrderList { get; set; }
        public virtual DbSet<CIQ_NB_RouteData> CIQ_NB_RouteData { get; set; }
        public virtual DbSet<CIQ_NB_SaleOrder> CIQ_NB_SaleOrder { get; set; }
        public virtual DbSet<CIQ_NB_SaleOrder_Audit> CIQ_NB_SaleOrder_Audit { get; set; }
        public virtual DbSet<CIQ_NB_SaleOrder_Down> CIQ_NB_SaleOrder_Down { get; set; }
        public virtual DbSet<CIQ_NB_SaleOrder_Out> CIQ_NB_SaleOrder_Out { get; set; }
        public virtual DbSet<CIQ_NB_SaleOrder_OutList> CIQ_NB_SaleOrder_OutList { get; set; }
        public virtual DbSet<CIQ_NB_SaleOrder_State> CIQ_NB_SaleOrder_State { get; set; }
        public virtual DbSet<CIQ_NB_SaleOrderConfirm> CIQ_NB_SaleOrderConfirm { get; set; }
        public virtual DbSet<CIQ_NB_SaleOrderConfirmList> CIQ_NB_SaleOrderConfirmList { get; set; }
        public virtual DbSet<CIQ_NB_SaleOrderList> CIQ_NB_SaleOrderList { get; set; }
        public virtual DbSet<CIQ_NB_StorageRelation> CIQ_NB_StorageRelation { get; set; }
        public virtual DbSet<CIQ_NB_TranVirtualScan> CIQ_NB_TranVirtualScan { get; set; }
        public virtual DbSet<CIQ_Order> CIQ_Order { get; set; }
        public virtual DbSet<CIQ_OrderList> CIQ_OrderList { get; set; }
        public virtual DbSet<CIQ_ResMsg> CIQ_ResMsg { get; set; }
        public virtual DbSet<CMS_Content> CMS_Content { get; set; }
        public virtual DbSet<CMS_Content_ProductDetail> CMS_Content_ProductDetail { get; set; }
        public virtual DbSet<CMS_Content_ProductLibDetail> CMS_Content_ProductLibDetail { get; set; }
        public virtual DbSet<CMS_Module> CMS_Module { get; set; }
        public virtual DbSet<Cnec_jh_Decl_Byorder> Cnec_jh_Decl_Byorder { get; set; }
        public virtual DbSet<Cnec_jh_Order> Cnec_jh_Order { get; set; }
        public virtual DbSet<Cnec_jh_OrderList> Cnec_jh_OrderList { get; set; }
        public virtual DbSet<Cnec_jh_Pay> Cnec_jh_Pay { get; set; }
        public virtual DbSet<ContainerIsFullOrEmpty> ContainerIsFullOrEmpty { get; set; }
        public virtual DbSet<containerType> containerType { get; set; }
        public virtual DbSet<CRM_Calendar> CRM_Calendar { get; set; }
        public virtual DbSet<CRM_ClientCare> CRM_ClientCare { get; set; }
        public virtual DbSet<CRM_ClientComplain> CRM_ClientComplain { get; set; }
        public virtual DbSet<CRM_ClientLinker> CRM_ClientLinker { get; set; }
        public virtual DbSet<CRM_ClientLinkerRemind> CRM_ClientLinkerRemind { get; set; }
        public virtual DbSet<CRM_ClientLog> CRM_ClientLog { get; set; }
        public virtual DbSet<CRM_ClientService> CRM_ClientService { get; set; }
        public virtual DbSet<CRM_Competitor> CRM_Competitor { get; set; }
        public virtual DbSet<CRM_QALib> CRM_QALib { get; set; }
        public virtual DbSet<CRM_QALibType> CRM_QALibType { get; set; }
        public virtual DbSet<CRM_SaleChance> CRM_SaleChance { get; set; }
        public virtual DbSet<CRM_SaleChanceList> CRM_SaleChanceList { get; set; }
        public virtual DbSet<CRM_SaleCost> CRM_SaleCost { get; set; }
        public virtual DbSet<CRM_SaleQuotation> CRM_SaleQuotation { get; set; }
        public virtual DbSet<CRM_SaleQuotationList> CRM_SaleQuotationList { get; set; }
        public virtual DbSet<CRM_SaleRequest> CRM_SaleRequest { get; set; }
        public virtual DbSet<CRM_Schedule> CRM_Schedule { get; set; }
        public virtual DbSet<CRM_Solution> CRM_Solution { get; set; }
        public virtual DbSet<deviceGeneralInfo> deviceGeneralInfo { get; set; }
        public virtual DbSet<eBay_Category_Relation> eBay_Category_Relation { get; set; }
        public virtual DbSet<eBay_Category_Root> eBay_Category_Root { get; set; }
        public virtual DbSet<eBay_Client_Relation> eBay_Client_Relation { get; set; }
        public virtual DbSet<eBay_Message> eBay_Message { get; set; }
        public virtual DbSet<eBay_Message_Reply> eBay_Message_Reply { get; set; }
        public virtual DbSet<eBay_Order_Relation> eBay_Order_Relation { get; set; }
        public virtual DbSet<eBay_OrderList_Relation> eBay_OrderList_Relation { get; set; }
        public virtual DbSet<eBay_ShipmentCarries> eBay_ShipmentCarries { get; set; }
        public virtual DbSet<eBay_SiteCodeType> eBay_SiteCodeType { get; set; }
        public virtual DbSet<eBay_SKU_ListingDetails> eBay_SKU_ListingDetails { get; set; }
        public virtual DbSet<eBay_SKU_Relation> eBay_SKU_Relation { get; set; }
        public virtual DbSet<eBay_SKU_VariationItem> eBay_SKU_VariationItem { get; set; }
        public virtual DbSet<eBay_SKU_VariationSet> eBay_SKU_VariationSet { get; set; }
        public virtual DbSet<eBay_SKU_VariationValue> eBay_SKU_VariationValue { get; set; }
        public virtual DbSet<eBay_SKUImage_Relation> eBay_SKUImage_Relation { get; set; }
        public virtual DbSet<eBay_StoreInfo> eBay_StoreInfo { get; set; }
        public virtual DbSet<ERP_Interface> ERP_Interface { get; set; }
        public virtual DbSet<ERP_InterfaceList> ERP_InterfaceList { get; set; }
        public virtual DbSet<ERP_InterfacePush> ERP_InterfacePush { get; set; }
        public virtual DbSet<Express_Country_DeclaredValueRegular> Express_Country_DeclaredValueRegular { get; set; }
        public virtual DbSet<Express_Plt_Country> Express_Plt_Country { get; set; }
        public virtual DbSet<Express_PostPony> Express_PostPony { get; set; }
        public virtual DbSet<Express_PostPonyList> Express_PostPonyList { get; set; }
        public virtual DbSet<Express100_BaseInfo> Express100_BaseInfo { get; set; }
        public virtual DbSet<Express4PX_DeclareInvoice> Express4PX_DeclareInvoice { get; set; }
        public virtual DbSet<Express4PX_Error> Express4PX_Error { get; set; }
        public virtual DbSet<Express4PX_Order> Express4PX_Order { get; set; }
        public virtual DbSet<Express4PX_ProductCode> Express4PX_ProductCode { get; set; }
        public virtual DbSet<Express4PX_TrackInfo> Express4PX_TrackInfo { get; set; }
        public virtual DbSet<ExpressAfterShip_Tracking> ExpressAfterShip_Tracking { get; set; }
        public virtual DbSet<ExpressBpost_M2m_Order> ExpressBpost_M2m_Order { get; set; }
        public virtual DbSet<ExpressBpost_Order> ExpressBpost_Order { get; set; }
        public virtual DbSet<ExpressBpost_OrderList> ExpressBpost_OrderList { get; set; }
        public virtual DbSet<ExpressBSHT_BaseInfo> ExpressBSHT_BaseInfo { get; set; }
        public virtual DbSet<ExpressBSHT_Order> ExpressBSHT_Order { get; set; }
        public virtual DbSet<ExpressBSHT_OrderList> ExpressBSHT_OrderList { get; set; }
        public virtual DbSet<ExpressCK1_Package> ExpressCK1_Package { get; set; }
        public virtual DbSet<ExpressCK1_Product> ExpressCK1_Product { get; set; }
        public virtual DbSet<ExpressCK1_RegionCountry_Relation> ExpressCK1_RegionCountry_Relation { get; set; }
        public virtual DbSet<ExpressDHL_Country> ExpressDHL_Country { get; set; }
        public virtual DbSet<ExpressDHL_Order> ExpressDHL_Order { get; set; }
        public virtual DbSet<ExpressDHL_OrderList> ExpressDHL_OrderList { get; set; }
        public virtual DbSet<ExpressDHL_Transfter> ExpressDHL_Transfter { get; set; }
        public virtual DbSet<ExpressDHL_TransfterList> ExpressDHL_TransfterList { get; set; }
        public virtual DbSet<ExpressEasyPost_Order> ExpressEasyPost_Order { get; set; }
        public virtual DbSet<ExpressEasyPost_OrderList> ExpressEasyPost_OrderList { get; set; }
        public virtual DbSet<ExpressEasyPost_Refunds> ExpressEasyPost_Refunds { get; set; }
        public virtual DbSet<ExpressEbayEUB_Order> ExpressEbayEUB_Order { get; set; }
        public virtual DbSet<ExpressEbayEUB_OrderList> ExpressEbayEUB_OrderList { get; set; }
        public virtual DbSet<ExpressEMS_Order> ExpressEMS_Order { get; set; }
        public virtual DbSet<ExpressEMS_OrderList> ExpressEMS_OrderList { get; set; }
        public virtual DbSet<ExpressEMS_OrderRoute> ExpressEMS_OrderRoute { get; set; }
        public virtual DbSet<ExpressEUB_Order> ExpressEUB_Order { get; set; }
        public virtual DbSet<ExpressEUB_OrderList> ExpressEUB_OrderList { get; set; }
        public virtual DbSet<ExpressEUB_USAZip> ExpressEUB_USAZip { get; set; }
        public virtual DbSet<ExpressKD100_OrderRoute> ExpressKD100_OrderRoute { get; set; }
        public virtual DbSet<ExpressQZPort_Order> ExpressQZPort_Order { get; set; }
        public virtual DbSet<ExpressQZPort_OrderList> ExpressQZPort_OrderList { get; set; }
        public virtual DbSet<ExpressQZPort_OrderRoute> ExpressQZPort_OrderRoute { get; set; }
        public virtual DbSet<ExpressSF_BaseInfo> ExpressSF_BaseInfo { get; set; }
        public virtual DbSet<ExpressSF_Order> ExpressSF_Order { get; set; }
        public virtual DbSet<ExpressSF_OrderFilter> ExpressSF_OrderFilter { get; set; }
        public virtual DbSet<ExpressSF_OrderList> ExpressSF_OrderList { get; set; }
        public virtual DbSet<ExpressSF_OrderRoute> ExpressSF_OrderRoute { get; set; }
        public virtual DbSet<ExpressSharpCentury_Order> ExpressSharpCentury_Order { get; set; }
        public virtual DbSet<ExpressSharpCentury_OrderList> ExpressSharpCentury_OrderList { get; set; }
        public virtual DbSet<ExpressShipStation_Carrier> ExpressShipStation_Carrier { get; set; }
        public virtual DbSet<ExpressShipStation_Order> ExpressShipStation_Order { get; set; }
        public virtual DbSet<ExpressShipStation_OrderList> ExpressShipStation_OrderList { get; set; }
        public virtual DbSet<ExpressShipStation_PackageType> ExpressShipStation_PackageType { get; set; }
        public virtual DbSet<ExpressShipStation_ShippingProvider> ExpressShipStation_ShippingProvider { get; set; }
        public virtual DbSet<ExpressShipStation_ShippingService> ExpressShipStation_ShippingService { get; set; }
        public virtual DbSet<ExpressShipStation_Store> ExpressShipStation_Store { get; set; }
        public virtual DbSet<ExpressSpare_Order> ExpressSpare_Order { get; set; }
        public virtual DbSet<ExpressStamps_Order> ExpressStamps_Order { get; set; }
        public virtual DbSet<ExpressStamps_OrderList> ExpressStamps_OrderList { get; set; }
        public virtual DbSet<ExpressStandardEUB_Order> ExpressStandardEUB_Order { get; set; }
        public virtual DbSet<ExpressStandardEUB_OrderList> ExpressStandardEUB_OrderList { get; set; }
        public virtual DbSet<ExpressSTO_BaseInfo> ExpressSTO_BaseInfo { get; set; }
        public virtual DbSet<ExpressSTO_Order> ExpressSTO_Order { get; set; }
        public virtual DbSet<ExpressSTO_OrderRoute> ExpressSTO_OrderRoute { get; set; }
        public virtual DbSet<ExpressUPS_Country> ExpressUPS_Country { get; set; }
        public virtual DbSet<ExpressUPS_Order> ExpressUPS_Order { get; set; }
        public virtual DbSet<ExpressUPS_OrderList> ExpressUPS_OrderList { get; set; }
        public virtual DbSet<ExpressUPS_StateCode> ExpressUPS_StateCode { get; set; }
        public virtual DbSet<ExpressWinit_Order> ExpressWinit_Order { get; set; }
        public virtual DbSet<ExpressWinit_Product> ExpressWinit_Product { get; set; }
        public virtual DbSet<ExpressWinit_Sku_Relation> ExpressWinit_Sku_Relation { get; set; }
        public virtual DbSet<ExpressWinit_WareHouse_Relation> ExpressWinit_WareHouse_Relation { get; set; }
        public virtual DbSet<ExpressYT_BaseInfo> ExpressYT_BaseInfo { get; set; }
        public virtual DbSet<ExpressYT_Order> ExpressYT_Order { get; set; }
        public virtual DbSet<ExpressYT_OrderList> ExpressYT_OrderList { get; set; }
        public virtual DbSet<ExpressYT_OrderRoute> ExpressYT_OrderRoute { get; set; }
        public virtual DbSet<ExpressZT_BaseInfo> ExpressZT_BaseInfo { get; set; }
        public virtual DbSet<ExpressZT_Order> ExpressZT_Order { get; set; }
        public virtual DbSet<ExpressZT_OrderList> ExpressZT_OrderList { get; set; }
        public virtual DbSet<ExpressZT_OrderRoute> ExpressZT_OrderRoute { get; set; }
        public virtual DbSet<ExpressZT_OrderRoute_GuoJi> ExpressZT_OrderRoute_GuoJi { get; set; }
        public virtual DbSet<Fee_Base_OneCharge> Fee_Base_OneCharge { get; set; }
        public virtual DbSet<Fee_Base_Storagefee> Fee_Base_Storagefee { get; set; }
        public virtual DbSet<Fee_ChargeByArea> Fee_ChargeByArea { get; set; }
        public virtual DbSet<Fee_ChargeByPeriod> Fee_ChargeByPeriod { get; set; }
        public virtual DbSet<Fee_ChargeByPiece> Fee_ChargeByPiece { get; set; }
        public virtual DbSet<Fee_ChargeByPieceList> Fee_ChargeByPieceList { get; set; }
        public virtual DbSet<Fee_ChargeByPosition> Fee_ChargeByPosition { get; set; }
        public virtual DbSet<Fee_ChargeByPositionList> Fee_ChargeByPositionList { get; set; }
        public virtual DbSet<Fee_ChargeByPublicArea> Fee_ChargeByPublicArea { get; set; }
        public virtual DbSet<Fee_ChargeConsignorInfo> Fee_ChargeConsignorInfo { get; set; }
        public virtual DbSet<Fee_ChargeInfo> Fee_ChargeInfo { get; set; }
        public virtual DbSet<Fee_ChargeType> Fee_ChargeType { get; set; }
        public virtual DbSet<Fee_FeeItem> Fee_FeeItem { get; set; }
        public virtual DbSet<Fee_ItemByDay> Fee_ItemByDay { get; set; }
        public virtual DbSet<Fee_ItemConsignorInfo> Fee_ItemConsignorInfo { get; set; }
        public virtual DbSet<Fee_ItemInfo> Fee_ItemInfo { get; set; }
        public virtual DbSet<Fee_MonthBill> Fee_MonthBill { get; set; }
        public virtual DbSet<Fee_OtherRecord> Fee_OtherRecord { get; set; }
        public virtual DbSet<Fee_PayableBill> Fee_PayableBill { get; set; }
        public virtual DbSet<Fee_PayableBillDetail> Fee_PayableBillDetail { get; set; }
        public virtual DbSet<Fee_Statement> Fee_Statement { get; set; }
        public virtual DbSet<Fee_StatementDetail> Fee_StatementDetail { get; set; }
        public virtual DbSet<Fee_Workload> Fee_Workload { get; set; }
        public virtual DbSet<Finance_AccountChange> Finance_AccountChange { get; set; }
        public virtual DbSet<Finance_AccountChangeList> Finance_AccountChangeList { get; set; }
        public virtual DbSet<Finance_AccountCheck> Finance_AccountCheck { get; set; }
        public virtual DbSet<Finance_AccountItem> Finance_AccountItem { get; set; }
        public virtual DbSet<Finance_AccountItemAsset> Finance_AccountItemAsset { get; set; }
        public virtual DbSet<Finance_AccountItemMenu> Finance_AccountItemMenu { get; set; }
        public virtual DbSet<Finance_AccountItemMenu_Relation> Finance_AccountItemMenu_Relation { get; set; }
        public virtual DbSet<Finance_AccountVoucher> Finance_AccountVoucher { get; set; }
        public virtual DbSet<Finance_AccountVoucherList> Finance_AccountVoucherList { get; set; }
        public virtual DbSet<Finance_Adjustment> Finance_Adjustment { get; set; }
        public virtual DbSet<Finance_Adjustment_Provider> Finance_Adjustment_Provider { get; set; }
        public virtual DbSet<Finance_AssetDepreciation> Finance_AssetDepreciation { get; set; }
        public virtual DbSet<Finance_AssetDepreciationList> Finance_AssetDepreciationList { get; set; }
        public virtual DbSet<Finance_AssetFixed> Finance_AssetFixed { get; set; }
        public virtual DbSet<Finance_AssetFixedList> Finance_AssetFixedList { get; set; }
        public virtual DbSet<Finance_AssetSale> Finance_AssetSale { get; set; }
        public virtual DbSet<Finance_AssetSaleList> Finance_AssetSaleList { get; set; }
        public virtual DbSet<Finance_BankAccount> Finance_BankAccount { get; set; }
        public virtual DbSet<Finance_BankBiz> Finance_BankBiz { get; set; }
        public virtual DbSet<Finance_BankFee> Finance_BankFee { get; set; }
        public virtual DbSet<Finance_BankFeeList> Finance_BankFeeList { get; set; }
        public virtual DbSet<Finance_Fee> Finance_Fee { get; set; }
        public virtual DbSet<Finance_Fee_Income> Finance_Fee_Income { get; set; }
        public virtual DbSet<Finance_Fee_Transfer> Finance_Fee_Transfer { get; set; }
        public virtual DbSet<Finance_FeeList> Finance_FeeList { get; set; }
        public virtual DbSet<Finance_Flow> Finance_Flow { get; set; }
        public virtual DbSet<Finance_Pay_Purchase> Finance_Pay_Purchase { get; set; }
        public virtual DbSet<Finance_Pay_PurchaseList> Finance_Pay_PurchaseList { get; set; }
        public virtual DbSet<Finance_Pay_Return> Finance_Pay_Return { get; set; }
        public virtual DbSet<Finance_Pay_ReturnList> Finance_Pay_ReturnList { get; set; }
        public virtual DbSet<Finance_PayableDecrease> Finance_PayableDecrease { get; set; }
        public virtual DbSet<Finance_PayableDecreaseList> Finance_PayableDecreaseList { get; set; }
        public virtual DbSet<Finance_PayableIncrease> Finance_PayableIncrease { get; set; }
        public virtual DbSet<Finance_Payout> Finance_Payout { get; set; }
        public virtual DbSet<Finance_PayoutList> Finance_PayoutList { get; set; }
        public virtual DbSet<Finance_PrepaidAmortizement> Finance_PrepaidAmortizement { get; set; }
        public virtual DbSet<Finance_PrepaidAmortizementList> Finance_PrepaidAmortizementList { get; set; }
        public virtual DbSet<Finance_PrepaidOccurred> Finance_PrepaidOccurred { get; set; }
        public virtual DbSet<Finance_PrepaidOccurredList> Finance_PrepaidOccurredList { get; set; }
        public virtual DbSet<Finance_Prepay> Finance_Prepay { get; set; }
        public virtual DbSet<Finance_PrepayList> Finance_PrepayList { get; set; }
        public virtual DbSet<Finance_PrepayToPayout> Finance_PrepayToPayout { get; set; }
        public virtual DbSet<Finance_PrepayToPayoutList> Finance_PrepayToPayoutList { get; set; }
        public virtual DbSet<Finance_Prereceive> Finance_Prereceive { get; set; }
        public virtual DbSet<Finance_PrereceiveList> Finance_PrereceiveList { get; set; }
        public virtual DbSet<Finance_PrereceiveToReceive> Finance_PrereceiveToReceive { get; set; }
        public virtual DbSet<Finance_PrereceiveToReceiveList> Finance_PrereceiveToReceiveList { get; set; }
        public virtual DbSet<Finance_ReceivableDecrease> Finance_ReceivableDecrease { get; set; }
        public virtual DbSet<Finance_ReceivableDecreaseList> Finance_ReceivableDecreaseList { get; set; }
        public virtual DbSet<Finance_ReceivableIncrease> Finance_ReceivableIncrease { get; set; }
        public virtual DbSet<Finance_ReceivableIncreaseList> Finance_ReceivableIncreaseList { get; set; }
        public virtual DbSet<Finance_Receive> Finance_Receive { get; set; }
        public virtual DbSet<Finance_ReceiveList> Finance_ReceiveList { get; set; }
        public virtual DbSet<Finance_ReceiveOther> Finance_ReceiveOther { get; set; }
        public virtual DbSet<Finance_ReceiveOtherList> Finance_ReceiveOtherList { get; set; }
        public virtual DbSet<GuanYi_Product> GuanYi_Product { get; set; }
        public virtual DbSet<GuanYi_ProductSKU> GuanYi_ProductSKU { get; set; }
        public virtual DbSet<GuanYi_SaleOrder> GuanYi_SaleOrder { get; set; }
        public virtual DbSet<GuanYi_SaleOrderList> GuanYi_SaleOrderList { get; set; }
        public virtual DbSet<GuanYi_StoreInfo> GuanYi_StoreInfo { get; set; }
        public virtual DbSet<IDX_PickToLight> IDX_PickToLight { get; set; }
        public virtual DbSet<JingDong_Product> JingDong_Product { get; set; }
        public virtual DbSet<JingDong_ProductSKU> JingDong_ProductSKU { get; set; }
        public virtual DbSet<JingDong_SaleOrder> JingDong_SaleOrder { get; set; }
        public virtual DbSet<JingDong_SaleOrderList> JingDong_SaleOrderList { get; set; }
        public virtual DbSet<JingDong_StoreInfo> JingDong_StoreInfo { get; set; }
        public virtual DbSet<lackOrder> lackOrder { get; set; }
        public virtual DbSet<lackOrderList> lackOrderList { get; set; }
        public virtual DbSet<Log_StorageStatusChange> Log_StorageStatusChange { get; set; }
        public virtual DbSet<Magento_AttributeSet> Magento_AttributeSet { get; set; }
        public virtual DbSet<Magento_Catalog_Relation> Magento_Catalog_Relation { get; set; }
        public virtual DbSet<Magento_Client_Relation> Magento_Client_Relation { get; set; }
        public virtual DbSet<Magento_Country_Relation> Magento_Country_Relation { get; set; }
        public virtual DbSet<Magento_Order_Relation> Magento_Order_Relation { get; set; }
        public virtual DbSet<Magento_OrderList_Relation> Magento_OrderList_Relation { get; set; }
        public virtual DbSet<Magento_OrderShipment> Magento_OrderShipment { get; set; }
        public virtual DbSet<Magento_OrderShipmentCreate> Magento_OrderShipmentCreate { get; set; }
        public virtual DbSet<Magento_OrderShipmentCreate_Item> Magento_OrderShipmentCreate_Item { get; set; }
        public virtual DbSet<Magento_OrderShipmentCreate_Track> Magento_OrderShipmentCreate_Track { get; set; }
        public virtual DbSet<Magento_OrderStatus_Relation> Magento_OrderStatus_Relation { get; set; }
        public virtual DbSet<Magento_Region_Relation> Magento_Region_Relation { get; set; }
        public virtual DbSet<Magento_SKU_Relation> Magento_SKU_Relation { get; set; }
        public virtual DbSet<Magento_SKUCustomOption_Relation> Magento_SKUCustomOption_Relation { get; set; }
        public virtual DbSet<Magento_SKUCustomOptionAdditionalField> Magento_SKUCustomOptionAdditionalField { get; set; }
        public virtual DbSet<Magento_SKUCustomOptionValue_Relation> Magento_SKUCustomOptionValue_Relation { get; set; }
        public virtual DbSet<Magento_SKUImage_Relation> Magento_SKUImage_Relation { get; set; }
        public virtual DbSet<Magento_StoreInfo> Magento_StoreInfo { get; set; }
        public virtual DbSet<Mangento_Shipment> Mangento_Shipment { get; set; }
        public virtual DbSet<Mangento_ShipmentCarries> Mangento_ShipmentCarries { get; set; }
        public virtual DbSet<Mangento_ShipmentComment> Mangento_ShipmentComment { get; set; }
        public virtual DbSet<Mangento_ShipmentTrack> Mangento_ShipmentTrack { get; set; }
        public virtual DbSet<MoYun_Sale_Order_Status> MoYun_Sale_Order_Status { get; set; }
        public virtual DbSet<MoYun_Sale_Order_Tran> MoYun_Sale_Order_Tran { get; set; }
        public virtual DbSet<MoYun_Sale_Order_TranList> MoYun_Sale_Order_TranList { get; set; }
        public virtual DbSet<Msg_BaseInfo> Msg_BaseInfo { get; set; }
        public virtual DbSet<Msg_Template> Msg_Template { get; set; }
        public virtual DbSet<Msg_UserContent> Msg_UserContent { get; set; }
        public virtual DbSet<Msg_UserRelation> Msg_UserRelation { get; set; }
        public virtual DbSet<OA_CommonMessage> OA_CommonMessage { get; set; }
        public virtual DbSet<OA_CommonMessageType> OA_CommonMessageType { get; set; }
        public virtual DbSet<OA_Notice> OA_Notice { get; set; }
        public virtual DbSet<OA_RegUser_StatusHistory> OA_RegUser_StatusHistory { get; set; }
        public virtual DbSet<OA_RegUserInfo> OA_RegUserInfo { get; set; }
        public virtual DbSet<OA_ReportDay> OA_ReportDay { get; set; }
        public virtual DbSet<OA_ReportMonth> OA_ReportMonth { get; set; }
        public virtual DbSet<OA_ReportWeek> OA_ReportWeek { get; set; }
        public virtual DbSet<OutInStockTask> OutInStockTask { get; set; }
        public virtual DbSet<Purchase_ArrivalProcess> Purchase_ArrivalProcess { get; set; }
        public virtual DbSet<Purchase_ArrivalProcessList> Purchase_ArrivalProcessList { get; set; }
        public virtual DbSet<Purchase_DamagedOrder> Purchase_DamagedOrder { get; set; }
        public virtual DbSet<Purchase_DamagedOrderList> Purchase_DamagedOrderList { get; set; }
        public virtual DbSet<Purchase_Enter> Purchase_Enter { get; set; }
        public virtual DbSet<Purchase_EnterList> Purchase_EnterList { get; set; }
        public virtual DbSet<Purchase_Exchange> Purchase_Exchange { get; set; }
        public virtual DbSet<Purchase_ExchangeEnterList> Purchase_ExchangeEnterList { get; set; }
        public virtual DbSet<Purchase_ExchangeOuterList> Purchase_ExchangeOuterList { get; set; }
        public virtual DbSet<Purchase_InventoryProcess> Purchase_InventoryProcess { get; set; }
        public virtual DbSet<Purchase_InventoryProcessList> Purchase_InventoryProcessList { get; set; }
        public virtual DbSet<Purchase_Order> Purchase_Order { get; set; }
        public virtual DbSet<Purchase_Order_ArriveDate> Purchase_Order_ArriveDate { get; set; }
        public virtual DbSet<Purchase_Order_Paid> Purchase_Order_Paid { get; set; }
        public virtual DbSet<Purchase_Order_StatusHistory> Purchase_Order_StatusHistory { get; set; }
        public virtual DbSet<Purchase_Order_Temp> Purchase_Order_Temp { get; set; }
        public virtual DbSet<Purchase_OrderList> Purchase_OrderList { get; set; }
        public virtual DbSet<Purchase_OrderRush> Purchase_OrderRush { get; set; }
        public virtual DbSet<Purchase_OrderRushList> Purchase_OrderRushList { get; set; }
        public virtual DbSet<Purchase_ProductionOrder> Purchase_ProductionOrder { get; set; }
        public virtual DbSet<Purchase_QualityCheck> Purchase_QualityCheck { get; set; }
        public virtual DbSet<Purchase_QualityCheckList> Purchase_QualityCheckList { get; set; }
        public virtual DbSet<Purchase_Quotation> Purchase_Quotation { get; set; }
        public virtual DbSet<Purchase_QuotationList> Purchase_QuotationList { get; set; }
        public virtual DbSet<Purchase_Requisition> Purchase_Requisition { get; set; }
        public virtual DbSet<Purchase_RequisitionList> Purchase_RequisitionList { get; set; }
        public virtual DbSet<Purchase_Return> Purchase_Return { get; set; }
        public virtual DbSet<Purchase_Return_StatusHistory> Purchase_Return_StatusHistory { get; set; }
        public virtual DbSet<Purchase_ReturnList> Purchase_ReturnList { get; set; }
        public virtual DbSet<Purchase_Shelve> Purchase_Shelve { get; set; }
        public virtual DbSet<Purchase_ShelveList> Purchase_ShelveList { get; set; }
        public virtual DbSet<Purchase_ShelveListDetail> Purchase_ShelveListDetail { get; set; }
        public virtual DbSet<Purchase_StepFinished> Purchase_StepFinished { get; set; }
        public virtual DbSet<Qimen_DeliveryOrder> Qimen_DeliveryOrder { get; set; }
        public virtual DbSet<Qimen_DeliveryOrder_Batch_Answer> Qimen_DeliveryOrder_Batch_Answer { get; set; }
        public virtual DbSet<Qimen_DeliveryOrder_Batch_DeliveryOrders> Qimen_DeliveryOrder_Batch_DeliveryOrders { get; set; }
        public virtual DbSet<Qimen_DeliveryOrder_Batch_OrderLines> Qimen_DeliveryOrder_Batch_OrderLines { get; set; }
        public virtual DbSet<Qimen_DeliveryOrder_OrderLines> Qimen_DeliveryOrder_OrderLines { get; set; }
        public virtual DbSet<Qimen_DeliveryOrder_StatusHistory> Qimen_DeliveryOrder_StatusHistory { get; set; }
        public virtual DbSet<Qimen_EntryOrder> Qimen_EntryOrder { get; set; }
        public virtual DbSet<Qimen_EntryOrder_OrderLines> Qimen_EntryOrder_OrderLines { get; set; }
        public virtual DbSet<Qimen_EntryOrder_StatusHistory> Qimen_EntryOrder_StatusHistory { get; set; }
        public virtual DbSet<Qimen_Inventory_Report> Qimen_Inventory_Report { get; set; }
        public virtual DbSet<Qimen_Inventory_Report_Items> Qimen_Inventory_Report_Items { get; set; }
        public virtual DbSet<Qimen_Itemlack_Report> Qimen_Itemlack_Report { get; set; }
        public virtual DbSet<Qimen_Itemlack_Report_Items> Qimen_Itemlack_Report_Items { get; set; }
        public virtual DbSet<Qimen_Order_Pending> Qimen_Order_Pending { get; set; }
        public virtual DbSet<Qimen_OrderException_OrderLines> Qimen_OrderException_OrderLines { get; set; }
        public virtual DbSet<Qimen_OrderException_Report> Qimen_OrderException_Report { get; set; }
        public virtual DbSet<Qimen_OrderProcess_Report> Qimen_OrderProcess_Report { get; set; }
        public virtual DbSet<Qimen_ReturnOrder> Qimen_ReturnOrder { get; set; }
        public virtual DbSet<Qimen_ReturnOrder_OrderLines> Qimen_ReturnOrder_OrderLines { get; set; }
        public virtual DbSet<Qimen_Singleitem_Synchronize> Qimen_Singleitem_Synchronize { get; set; }
        public virtual DbSet<Qimen_Sn_Report> Qimen_Sn_Report { get; set; }
        public virtual DbSet<Qimen_Sn_Report_Items> Qimen_Sn_Report_Items { get; set; }
        public virtual DbSet<Qimen_StockChange_Report> Qimen_StockChange_Report { get; set; }
        public virtual DbSet<Qimen_StockChange_Report_Batchs> Qimen_StockChange_Report_Batchs { get; set; }
        public virtual DbSet<Qimen_StockOut> Qimen_StockOut { get; set; }
        public virtual DbSet<Qimen_StockOut_OrderLines> Qimen_StockOut_OrderLines { get; set; }
        public virtual DbSet<Qimen_StoreInfo> Qimen_StoreInfo { get; set; }
        public virtual DbSet<Qimen_StoreProcess> Qimen_StoreProcess { get; set; }
        public virtual DbSet<Qimen_StoreProcess_MaterialItems> Qimen_StoreProcess_MaterialItems { get; set; }
        public virtual DbSet<Qimen_StoreProcess_ProductItems> Qimen_StoreProcess_ProductItems { get; set; }
        public virtual DbSet<Qimen_Wavenum_Report> Qimen_Wavenum_Report { get; set; }
        public virtual DbSet<Qimen_Wavenum_Report_Order> Qimen_Wavenum_Report_Order { get; set; }
        public virtual DbSet<region_directory> region_directory { get; set; }
        public virtual DbSet<Require_Allocation> Require_Allocation { get; set; }
        public virtual DbSet<Require_AllocationList> Require_AllocationList { get; set; }
        public virtual DbSet<Require_Goods> Require_Goods { get; set; }
        public virtual DbSet<Require_GoodsList> Require_GoodsList { get; set; }
        public virtual DbSet<Require_Voucher> Require_Voucher { get; set; }
        public virtual DbSet<Rule_Bundle> Rule_Bundle { get; set; }
        public virtual DbSet<Rule_BundleList> Rule_BundleList { get; set; }
        public virtual DbSet<Rule_Coupon> Rule_Coupon { get; set; }
        public virtual DbSet<Rule_FlashSale> Rule_FlashSale { get; set; }
        public virtual DbSet<Rule_Gift> Rule_Gift { get; set; }
        public virtual DbSet<Rule_GiftImage> Rule_GiftImage { get; set; }
        public virtual DbSet<Rule_GroupBuy> Rule_GroupBuy { get; set; }
        public virtual DbSet<Rule_MixedBatch> Rule_MixedBatch { get; set; }
        public virtual DbSet<Rule_OrderPromotion> Rule_OrderPromotion { get; set; }
        public virtual DbSet<Rule_OrderPromotionList> Rule_OrderPromotionList { get; set; }
        public virtual DbSet<Rule_Point> Rule_Point { get; set; }
        public virtual DbSet<Rule_ProductPromotion> Rule_ProductPromotion { get; set; }
        public virtual DbSet<Rule_ProductPromotionGift> Rule_ProductPromotionGift { get; set; }
        public virtual DbSet<Rule_ProductPromotionList> Rule_ProductPromotionList { get; set; }
        public virtual DbSet<Rule_WholeSale> Rule_WholeSale { get; set; }
        public virtual DbSet<Sale_BatchWeigh> Sale_BatchWeigh { get; set; }
        public virtual DbSet<Sale_Exchange> Sale_Exchange { get; set; }
        public virtual DbSet<Sale_ExchangeEnterList> Sale_ExchangeEnterList { get; set; }
        public virtual DbSet<Sale_ExchangeOuterList> Sale_ExchangeOuterList { get; set; }
        public virtual DbSet<Sale_FAQ> Sale_FAQ { get; set; }
        public virtual DbSet<Sale_LoadBill> Sale_LoadBill { get; set; }
        public virtual DbSet<Sale_LoadBill_Image> Sale_LoadBill_Image { get; set; }
        public virtual DbSet<Sale_LoadBill_Trajectory> Sale_LoadBill_Trajectory { get; set; }
        public virtual DbSet<Sale_LoadBillList> Sale_LoadBillList { get; set; }
        public virtual DbSet<Sale_Order> Sale_Order { get; set; }
        public virtual DbSet<Sale_Order_Paid> Sale_Order_Paid { get; set; }
        public virtual DbSet<Sale_Order_ProductSplit> Sale_Order_ProductSplit { get; set; }
        public virtual DbSet<Sale_Order_ProductSplitList> Sale_Order_ProductSplitList { get; set; }
        public virtual DbSet<Sale_Order_SortingBatch> Sale_Order_SortingBatch { get; set; }
        public virtual DbSet<Sale_Order_SortLevel> Sale_Order_SortLevel { get; set; }
        public virtual DbSet<Sale_Order_SortPool> Sale_Order_SortPool { get; set; }
        public virtual DbSet<Sale_Order_StatusHistory> Sale_Order_StatusHistory { get; set; }
        public virtual DbSet<Sale_Order_StatusHistory_CIQ> Sale_Order_StatusHistory_CIQ { get; set; }
        public virtual DbSet<Sale_Order_Temp> Sale_Order_Temp { get; set; }
        public virtual DbSet<Sale_Order_TempHold> Sale_Order_TempHold { get; set; }
        public virtual DbSet<Sale_OrderList> Sale_OrderList { get; set; }
        public virtual DbSet<Sale_OrderMatching> Sale_OrderMatching { get; set; }
        public virtual DbSet<Sale_OrderMatchingList> Sale_OrderMatchingList { get; set; }
        public virtual DbSet<Sale_OrderMerge> Sale_OrderMerge { get; set; }
        public virtual DbSet<Sale_OrderPicking> Sale_OrderPicking { get; set; }
        public virtual DbSet<Sale_OrderPickingList> Sale_OrderPickingList { get; set; }
        public virtual DbSet<Sale_OrderPlan> Sale_OrderPlan { get; set; }
        public virtual DbSet<Sale_OrderPlanDetail> Sale_OrderPlanDetail { get; set; }
        public virtual DbSet<Sale_OrderPrint> Sale_OrderPrint { get; set; }
        public virtual DbSet<Sale_OrderPrint_Tmp> Sale_OrderPrint_Tmp { get; set; }
        public virtual DbSet<Sale_OrderPrintList> Sale_OrderPrintList { get; set; }
        public virtual DbSet<Sale_OrderPrintList_Tmp> Sale_OrderPrintList_Tmp { get; set; }
        public virtual DbSet<Sale_OrderPrintListDetail> Sale_OrderPrintListDetail { get; set; }
        public virtual DbSet<Sale_OrderPrintPick> Sale_OrderPrintPick { get; set; }
        public virtual DbSet<Sale_OrderPrintPickList> Sale_OrderPrintPickList { get; set; }
        public virtual DbSet<Sale_OrderPrintSub> Sale_OrderPrintSub { get; set; }
        public virtual DbSet<Sale_Outer> Sale_Outer { get; set; }
        public virtual DbSet<Sale_OuterList> Sale_OuterList { get; set; }
        public virtual DbSet<Sale_OuterWrapper> Sale_OuterWrapper { get; set; }
        public virtual DbSet<Sale_Retail> Sale_Retail { get; set; }
        public virtual DbSet<Sale_RetailList> Sale_RetailList { get; set; }
        public virtual DbSet<Sale_Return> Sale_Return { get; set; }
        public virtual DbSet<Sale_Return_StatusHistory> Sale_Return_StatusHistory { get; set; }
        public virtual DbSet<Sale_ReturnList> Sale_ReturnList { get; set; }
        public virtual DbSet<Sale_Send> Sale_Send { get; set; }
        public virtual DbSet<Sale_SendList> Sale_SendList { get; set; }
        public virtual DbSet<Sale_SendWeigh> Sale_SendWeigh { get; set; }
        public virtual DbSet<Sale_SortingRule_BatchNum> Sale_SortingRule_BatchNum { get; set; }
        public virtual DbSet<Sale_SortingRule_Position> Sale_SortingRule_Position { get; set; }
        public virtual DbSet<Sale_SortingRule_ProductDate> Sale_SortingRule_ProductDate { get; set; }
        public virtual DbSet<Sale_Transfter> Sale_Transfter { get; set; }
        public virtual DbSet<Sale_Transfter_StatusHistory> Sale_Transfter_StatusHistory { get; set; }
        public virtual DbSet<Sale_TransfterCheck> Sale_TransfterCheck { get; set; }
        public virtual DbSet<Sale_TransfterCheckList> Sale_TransfterCheckList { get; set; }
        public virtual DbSet<Sale_TransfterList> Sale_TransfterList { get; set; }
        public virtual DbSet<SapSendFailRecodInfo> SapSendFailRecodInfo { get; set; }
        public virtual DbSet<SapSendInfo> SapSendInfo { get; set; }
        public virtual DbSet<SKU_AttributeItem> SKU_AttributeItem { get; set; }
        public virtual DbSet<SKU_AttributeValue> SKU_AttributeValue { get; set; }
        public virtual DbSet<SKU_Product_ItemValue> SKU_Product_ItemValue { get; set; }
        public virtual DbSet<SKU_ProductType_ItemValue> SKU_ProductType_ItemValue { get; set; }
        public virtual DbSet<sortingList> sortingList { get; set; }
        public virtual DbSet<Stat_StorageDay> Stat_StorageDay { get; set; }
        public virtual DbSet<Stat_StorageDayDetails> Stat_StorageDayDetails { get; set; }
        public virtual DbSet<Storage_Adjust> Storage_Adjust { get; set; }
        public virtual DbSet<Storage_AdjustList> Storage_AdjustList { get; set; }
        public virtual DbSet<Storage_AllocateApply> Storage_AllocateApply { get; set; }
        public virtual DbSet<Storage_AllocateApplyList> Storage_AllocateApplyList { get; set; }
        public virtual DbSet<Storage_AllocateEnter> Storage_AllocateEnter { get; set; }
        public virtual DbSet<Storage_AllocateEnterList> Storage_AllocateEnterList { get; set; }
        public virtual DbSet<Storage_Assemble> Storage_Assemble { get; set; }
        public virtual DbSet<Storage_AssembleEnterList> Storage_AssembleEnterList { get; set; }
        public virtual DbSet<Storage_AssembleOuterList> Storage_AssembleOuterList { get; set; }
        public virtual DbSet<Storage_BorrowEnter> Storage_BorrowEnter { get; set; }
        public virtual DbSet<Storage_BorrowEnterList> Storage_BorrowEnterList { get; set; }
        public virtual DbSet<Storage_BorrowEnterReturn> Storage_BorrowEnterReturn { get; set; }
        public virtual DbSet<Storage_BorrowEnterReturnList> Storage_BorrowEnterReturnList { get; set; }
        public virtual DbSet<Storage_BorrowOuter> Storage_BorrowOuter { get; set; }
        public virtual DbSet<Storage_BorrowOuterList> Storage_BorrowOuterList { get; set; }
        public virtual DbSet<Storage_BorrowOuterReturn> Storage_BorrowOuterReturn { get; set; }
        public virtual DbSet<Storage_BorrowOuterReturnList> Storage_BorrowOuterReturnList { get; set; }
        public virtual DbSet<Storage_Check> Storage_Check { get; set; }
        public virtual DbSet<Storage_CheckList> Storage_CheckList { get; set; }
        public virtual DbSet<Storage_CheckListDetail> Storage_CheckListDetail { get; set; }
        public virtual DbSet<Storage_ConsignorTransfer> Storage_ConsignorTransfer { get; set; }
        public virtual DbSet<Storage_ConsignorTransferList> Storage_ConsignorTransferList { get; set; }
        public virtual DbSet<Storage_Enter> Storage_Enter { get; set; }
        public virtual DbSet<Storage_EnterList> Storage_EnterList { get; set; }
        public virtual DbSet<Storage_Loss> Storage_Loss { get; set; }
        public virtual DbSet<Storage_LossList> Storage_LossList { get; set; }
        public virtual DbSet<Storage_Outer> Storage_Outer { get; set; }
        public virtual DbSet<Storage_OuterList> Storage_OuterList { get; set; }
        public virtual DbSet<Storage_PlateTransfer> Storage_PlateTransfer { get; set; }
        public virtual DbSet<Storage_PlateTransferList> Storage_PlateTransferList { get; set; }
        public virtual DbSet<Storage_PositionTransfer> Storage_PositionTransfer { get; set; }
        public virtual DbSet<Storage_PositionTransferList> Storage_PositionTransferList { get; set; }
        public virtual DbSet<Storage_Profit> Storage_Profit { get; set; }
        public virtual DbSet<Storage_ProfitList> Storage_ProfitList { get; set; }
        public virtual DbSet<Storage_ProfitLoss> Storage_ProfitLoss { get; set; }
        public virtual DbSet<Storage_ProfitLossList> Storage_ProfitLossList { get; set; }
        public virtual DbSet<Storage_PurchasePriceAdjust> Storage_PurchasePriceAdjust { get; set; }
        public virtual DbSet<Storage_PurchasePriceAdjustList> Storage_PurchasePriceAdjustList { get; set; }
        public virtual DbSet<Storage_Replenishment> Storage_Replenishment { get; set; }
        public virtual DbSet<Storage_Replenishment_SortingRule> Storage_Replenishment_SortingRule { get; set; }
        public virtual DbSet<Storage_ReplenishmentList> Storage_ReplenishmentList { get; set; }
        public virtual DbSet<Storage_ReplenishmentScan> Storage_ReplenishmentScan { get; set; }
        public virtual DbSet<Storage_ReplenishmentScanList> Storage_ReplenishmentScanList { get; set; }
        public virtual DbSet<Storage_ValidAdjust> Storage_ValidAdjust { get; set; }
        public virtual DbSet<Storage_ValidAdjustList> Storage_ValidAdjustList { get; set; }
        public virtual DbSet<Sts_DimDate> Sts_DimDate { get; set; }
        public virtual DbSet<Sts_NodeWarn> Sts_NodeWarn { get; set; }
        public virtual DbSet<Sys_BasicInfo> Sys_BasicInfo { get; set; }
        public virtual DbSet<Sys_CodeRegular> Sys_CodeRegular { get; set; }
        public virtual DbSet<Sys_CodeRegularUser> Sys_CodeRegularUser { get; set; }
        public virtual DbSet<Sys_ControlCenter> Sys_ControlCenter { get; set; }
        public virtual DbSet<Sys_DataAuthModule> Sys_DataAuthModule { get; set; }
        public virtual DbSet<Sys_DataAuthTemplate> Sys_DataAuthTemplate { get; set; }
        public virtual DbSet<Sys_Dept> Sys_Dept { get; set; }
        public virtual DbSet<Sys_DropDown> Sys_DropDown { get; set; }
        public virtual DbSet<Sys_ExportColumnInfo> Sys_ExportColumnInfo { get; set; }
        public virtual DbSet<Sys_ExportInfo> Sys_ExportInfo { get; set; }
        public virtual DbSet<Sys_ExportVueData> Sys_ExportVueData { get; set; }
        public virtual DbSet<Sys_Helper> Sys_Helper { get; set; }
        public virtual DbSet<Sys_ImportColumnInfo> Sys_ImportColumnInfo { get; set; }
        public virtual DbSet<Sys_ImportInfo> Sys_ImportInfo { get; set; }
        public virtual DbSet<Sys_Layout> Sys_Layout { get; set; }
        public virtual DbSet<Sys_Log> Sys_Log { get; set; }
        public virtual DbSet<Sys_Menu> Sys_Menu { get; set; }
        public virtual DbSet<Sys_MenuApp> Sys_MenuApp { get; set; }
        public virtual DbSet<Sys_MenuUser> Sys_MenuUser { get; set; }
        public virtual DbSet<Sys_MvcTableColumn> Sys_MvcTableColumn { get; set; }
        public virtual DbSet<Sys_MvcTableInfo> Sys_MvcTableInfo { get; set; }
        public virtual DbSet<Sys_MvcUserData> Sys_MvcUserData { get; set; }
        public virtual DbSet<Sys_MvcVueData> Sys_MvcVueData { get; set; }
        public virtual DbSet<Sys_ParamType> Sys_ParamType { get; set; }
        public virtual DbSet<Sys_ParamValue> Sys_ParamValue { get; set; }
        public virtual DbSet<Sys_ParamValue_OrderChannel> Sys_ParamValue_OrderChannel { get; set; }
        public virtual DbSet<Sys_Role> Sys_Role { get; set; }
        public virtual DbSet<Sys_Role_FieldAuth> Sys_Role_FieldAuth { get; set; }
        public virtual DbSet<Sys_Role_IsColumnAuth> Sys_Role_IsColumnAuth { get; set; }
        public virtual DbSet<Sys_Role_IsDataAuth> Sys_Role_IsDataAuth { get; set; }
        public virtual DbSet<Sys_RoleAuth> Sys_RoleAuth { get; set; }
        public virtual DbSet<Sys_RoleAuthData> Sys_RoleAuthData { get; set; }
        public virtual DbSet<Sys_RoleAuthDataAll> Sys_RoleAuthDataAll { get; set; }
        public virtual DbSet<Sys_Site> Sys_Site { get; set; }
        public virtual DbSet<Sys_StatCrossAxis> Sys_StatCrossAxis { get; set; }
        public virtual DbSet<Sys_StatInfo> Sys_StatInfo { get; set; }
        public virtual DbSet<Sys_StatOrdinateAxis> Sys_StatOrdinateAxis { get; set; }
        public virtual DbSet<Sys_StatWhere> Sys_StatWhere { get; set; }
        public virtual DbSet<Sys_User> Sys_User { get; set; }
        public virtual DbSet<Sys_User_Log> Sys_User_Log { get; set; }
        public virtual DbSet<Sys_UserConfig> Sys_UserConfig { get; set; }
        public virtual DbSet<sysdiagrams> sysdiagrams { get; set; }
        public virtual DbSet<TakeStock> TakeStock { get; set; }
        public virtual DbSet<Taobao_Category_Relation> Taobao_Category_Relation { get; set; }
        public virtual DbSet<Taobao_Client_Relation> Taobao_Client_Relation { get; set; }
        public virtual DbSet<Taobao_Picture_Relation> Taobao_Picture_Relation { get; set; }
        public virtual DbSet<Taobao_Product_Relation> Taobao_Product_Relation { get; set; }
        public virtual DbSet<Taobao_Product_Variation> Taobao_Product_Variation { get; set; }
        public virtual DbSet<Taobao_Product_VariationSet> Taobao_Product_VariationSet { get; set; }
        public virtual DbSet<Taobao_Product_VariationValue> Taobao_Product_VariationValue { get; set; }
        public virtual DbSet<Taobao_SaleOrder> Taobao_SaleOrder { get; set; }
        public virtual DbSet<Taobao_SaleOrderList> Taobao_SaleOrderList { get; set; }
        public virtual DbSet<Taobao_StoreInfo> Taobao_StoreInfo { get; set; }
        public virtual DbSet<Task_Queue> Task_Queue { get; set; }
        public virtual DbSet<Task_QueueLog> Task_QueueLog { get; set; }
        public virtual DbSet<Task_Step> Task_Step { get; set; }
        public virtual DbSet<Template_SendBill> Template_SendBill { get; set; }
        public virtual DbSet<Template_SendBillColumnInfo> Template_SendBillColumnInfo { get; set; }
        public virtual DbSet<Template_SendBillDetail> Template_SendBillDetail { get; set; }
        public virtual DbSet<Template_SendBillList> Template_SendBillList { get; set; }
        public virtual DbSet<TMS_Abnormal> TMS_Abnormal { get; set; }
        public virtual DbSet<TMS_Abnormal_Address> TMS_Abnormal_Address { get; set; }
        public virtual DbSet<TMS_AbnormalOrder> TMS_AbnormalOrder { get; set; }
        public virtual DbSet<TMS_Balance> TMS_Balance { get; set; }
        public virtual DbSet<TMS_BalanceList> TMS_BalanceList { get; set; }
        public virtual DbSet<TMS_Claim> TMS_Claim { get; set; }
        public virtual DbSet<TMS_Claim_Acceptance> TMS_Claim_Acceptance { get; set; }
        public virtual DbSet<TMS_CollectionRecord> TMS_CollectionRecord { get; set; }
        public virtual DbSet<TMS_Distribution> TMS_Distribution { get; set; }
        public virtual DbSet<TMS_DistributionDetail> TMS_DistributionDetail { get; set; }
        public virtual DbSet<TMS_Feedback> TMS_Feedback { get; set; }
        public virtual DbSet<TMS_FeeItem> TMS_FeeItem { get; set; }
        public virtual DbSet<TMS_FeeTemplate> TMS_FeeTemplate { get; set; }
        public virtual DbSet<TMS_FeeTemplateList> TMS_FeeTemplateList { get; set; }
        public virtual DbSet<TMS_FreightPrice> TMS_FreightPrice { get; set; }
        public virtual DbSet<Tms_GoodsRegion> Tms_GoodsRegion { get; set; }
        public virtual DbSet<TMS_IdCard> TMS_IdCard { get; set; }
        public virtual DbSet<TMS_Line> TMS_Line { get; set; }
        public virtual DbSet<TMS_MachineSortingLog> TMS_MachineSortingLog { get; set; }
        public virtual DbSet<TMS_OilCard> TMS_OilCard { get; set; }
        public virtual DbSet<TMS_OilConsume> TMS_OilConsume { get; set; }
        public virtual DbSet<TMS_OilRecharge> TMS_OilRecharge { get; set; }
        public virtual DbSet<TMS_OilSetup> TMS_OilSetup { get; set; }
        public virtual DbSet<TMS_PDAPrint> TMS_PDAPrint { get; set; }
        public virtual DbSet<TMS_Pickup> TMS_Pickup { get; set; }
        public virtual DbSet<TMS_PickupDetail> TMS_PickupDetail { get; set; }
        public virtual DbSet<TMS_Port> TMS_Port { get; set; }
        public virtual DbSet<TMS_PortTemplate> TMS_PortTemplate { get; set; }
        public virtual DbSet<TMS_PositionDetails> TMS_PositionDetails { get; set; }
        public virtual DbSet<TMS_ProductInfo_Port> TMS_ProductInfo_Port { get; set; }
        public virtual DbSet<TMS_Quotation> TMS_Quotation { get; set; }
        public virtual DbSet<TMS_QuotationList> TMS_QuotationList { get; set; }
        public virtual DbSet<TMS_Receive> TMS_Receive { get; set; }
        public virtual DbSet<TMS_RouterTask> TMS_RouterTask { get; set; }
        public virtual DbSet<TMS_ServicePart> TMS_ServicePart { get; set; }
        public virtual DbSet<TMS_Site> TMS_Site { get; set; }
        public virtual DbSet<TMS_SMS> TMS_SMS { get; set; }
        public virtual DbSet<TMS_SortingPanelLog> TMS_SortingPanelLog { get; set; }
        public virtual DbSet<TMS_Store> TMS_Store { get; set; }
        public virtual DbSet<TMS_Subsidy> TMS_Subsidy { get; set; }
        public virtual DbSet<TMS_Task> TMS_Task { get; set; }
        public virtual DbSet<TMS_TrackReplay> TMS_TrackReplay { get; set; }
        public virtual DbSet<TMS_Transport> TMS_Transport { get; set; }
        public virtual DbSet<TMS_TransportDetail> TMS_TransportDetail { get; set; }
        public virtual DbSet<TMS_TrayBill> TMS_TrayBill { get; set; }
        public virtual DbSet<TMS_TruckFeeList> TMS_TruckFeeList { get; set; }
        public virtual DbSet<TMS_TruckRecipient> TMS_TruckRecipient { get; set; }
        public virtual DbSet<TMS_Voyage> TMS_Voyage { get; set; }
        public virtual DbSet<TMS_VoyageList> TMS_VoyageList { get; set; }
        public virtual DbSet<TMS_WayBill> TMS_WayBill { get; set; }
        public virtual DbSet<TMS_WayBill_UpdateMobile> TMS_WayBill_UpdateMobile { get; set; }
        public virtual DbSet<TMS_WayBillAbnormal> TMS_WayBillAbnormal { get; set; }
        public virtual DbSet<TMS_WayBillHistory> TMS_WayBillHistory { get; set; }
        public virtual DbSet<TMS_WayBillList> TMS_WayBillList { get; set; }
        public virtual DbSet<TMS_WayBillOther> TMS_WayBillOther { get; set; }
        public virtual DbSet<TMS_WayBillOtherList> TMS_WayBillOtherList { get; set; }
        public virtual DbSet<TMS_WayBillReceive> TMS_WayBillReceive { get; set; }
        public virtual DbSet<TMS_WayBillReceiveTemp> TMS_WayBillReceiveTemp { get; set; }
        public virtual DbSet<TMS_WayBillTracking> TMS_WayBillTracking { get; set; }
        public virtual DbSet<TMS_WayBillUpload> TMS_WayBillUpload { get; set; }
        public virtual DbSet<TMS_WeiXin_Consignee> TMS_WeiXin_Consignee { get; set; }
        public virtual DbSet<TMS_WeiXin_WayBill> TMS_WeiXin_WayBill { get; set; }
        public virtual DbSet<TMS_WeiXin_WayBillList> TMS_WeiXin_WayBillList { get; set; }
        public virtual DbSet<Wdgj_Client_Relation> Wdgj_Client_Relation { get; set; }
        public virtual DbSet<Wdgj_Logistics> Wdgj_Logistics { get; set; }
        public virtual DbSet<Wdgj_Product> Wdgj_Product { get; set; }
        public virtual DbSet<Wdgj_ProductSKU> Wdgj_ProductSKU { get; set; }
        public virtual DbSet<Wdgj_SaleOrder> Wdgj_SaleOrder { get; set; }
        public virtual DbSet<Wdgj_SaleOrderList> Wdgj_SaleOrderList { get; set; }
        public virtual DbSet<Wdgj_StockIn> Wdgj_StockIn { get; set; }
        public virtual DbSet<Wdgj_StockInList> Wdgj_StockInList { get; set; }
        public virtual DbSet<Wdgj_StoreInfo> Wdgj_StoreInfo { get; set; }
        public virtual DbSet<Wdgj_Warehouse> Wdgj_Warehouse { get; set; }
        public virtual DbSet<WDT_Client_Relation> WDT_Client_Relation { get; set; }
        public virtual DbSet<WDT_ExpressRelation> WDT_ExpressRelation { get; set; }
        public virtual DbSet<WDT_Logisitis> WDT_Logisitis { get; set; }
        public virtual DbSet<WDT_Product> WDT_Product { get; set; }
        public virtual DbSet<WDT_ProductSKU> WDT_ProductSKU { get; set; }
        public virtual DbSet<WDT_SaleOrder> WDT_SaleOrder { get; set; }
        public virtual DbSet<WDT_SaleOrderList> WDT_SaleOrderList { get; set; }
        public virtual DbSet<WDT_StoreConsignorRelation> WDT_StoreConsignorRelation { get; set; }
        public virtual DbSet<WDT_StoreInfo> WDT_StoreInfo { get; set; }
        public virtual DbSet<Webgistix_ApiOrder> Webgistix_ApiOrder { get; set; }
        public virtual DbSet<Webgistix_ApiOrder_SKU> Webgistix_ApiOrder_SKU { get; set; }
        public virtual DbSet<Webgistix_ApiOrderDetail> Webgistix_ApiOrderDetail { get; set; }
        public virtual DbSet<Webgistix_AsnOrder> Webgistix_AsnOrder { get; set; }
        public virtual DbSet<Webgistix_AsnOrder_ProductPositionRelation> Webgistix_AsnOrder_ProductPositionRelation { get; set; }
        public virtual DbSet<Webgistix_AsnOrderDetail> Webgistix_AsnOrderDetail { get; set; }
        public virtual DbSet<Webgistix_Inventory> Webgistix_Inventory { get; set; }
        public virtual DbSet<Webgistix_ShippingTracking> Webgistix_ShippingTracking { get; set; }
        public virtual DbSet<Webgistix_SKU> Webgistix_SKU { get; set; }
        public virtual DbSet<Webgistix_StoreInfo> Webgistix_StoreInfo { get; set; }
        public virtual DbSet<Weidian_BasicInfo> Weidian_BasicInfo { get; set; }
        public virtual DbSet<Weidian_Order> Weidian_Order { get; set; }
        public virtual DbSet<Weidian_OrderDetail> Weidian_OrderDetail { get; set; }
        public virtual DbSet<Weidian_Product> Weidian_Product { get; set; }
        public virtual DbSet<WeiMeng_Category_Relation> WeiMeng_Category_Relation { get; set; }
        public virtual DbSet<WeiMeng_Order> WeiMeng_Order { get; set; }
        public virtual DbSet<WeiMeng_OrderList> WeiMeng_OrderList { get; set; }
        public virtual DbSet<WeiMeng_Product> WeiMeng_Product { get; set; }
        public virtual DbSet<WeiMeng_ProductSKU> WeiMeng_ProductSKU { get; set; }
        public virtual DbSet<WeiMeng_StoreInfo> WeiMeng_StoreInfo { get; set; }
        public virtual DbSet<Wish_Client_Relation> Wish_Client_Relation { get; set; }
        public virtual DbSet<Wish_Express_Relation> Wish_Express_Relation { get; set; }
        public virtual DbSet<Wish_Order_Fulfillment> Wish_Order_Fulfillment { get; set; }
        public virtual DbSet<Wish_Product> Wish_Product { get; set; }
        public virtual DbSet<Wish_SaleOrder> Wish_SaleOrder { get; set; }
        public virtual DbSet<Wish_StoreInfo> Wish_StoreInfo { get; set; }
        public virtual DbSet<Wms_FoldingPlateMachine> Wms_FoldingPlateMachine { get; set; }
        public virtual DbSet<AliExpress_Message> AliExpress_Message { get; set; }
        public virtual DbSet<Amazon_ProductTypeManual> Amazon_ProductTypeManual { get; set; }
        public virtual DbSet<Amazon_ProductTypeReport> Amazon_ProductTypeReport { get; set; }
        public virtual DbSet<Amazon_TmpCategory> Amazon_TmpCategory { get; set; }
        public virtual DbSet<Base_StorageArea_Regular> Base_StorageArea_Regular { get; set; }
        public virtual DbSet<Base_Trailer> Base_Trailer { get; set; }
        public virtual DbSet<eBay_SKUOther_Relation> eBay_SKUOther_Relation { get; set; }
        public virtual DbSet<ExpressBpost_M2m_OrderList> ExpressBpost_M2m_OrderList { get; set; }
        public virtual DbSet<Finance_PayableIncreaseList> Finance_PayableIncreaseList { get; set; }
        public virtual DbSet<Sale_Order_Transfter> Sale_Order_Transfter { get; set; }
        public virtual DbSet<v3D_Inventory> v3D_Inventory { get; set; }
        public virtual DbSet<v3D_Position> v3D_Position { get; set; }
        public virtual DbSet<vAliExpress_Message> vAliExpress_Message { get; set; }
        public virtual DbSet<vAliExpress_SKU> vAliExpress_SKU { get; set; }
        public virtual DbSet<vBase_Client_Arrears> vBase_Client_Arrears { get; set; }
        public virtual DbSet<vBase_Corp> vBase_Corp { get; set; }
        public virtual DbSet<vBase_Order_Statistics_Curve> vBase_Order_Statistics_Curve { get; set; }
        public virtual DbSet<vBase_PositionChannel> vBase_PositionChannel { get; set; }
        public virtual DbSet<vBase_PositionShelve> vBase_PositionShelve { get; set; }
        public virtual DbSet<vBase_ProductInfo> vBase_ProductInfo { get; set; }
        public virtual DbSet<vBase_ProductInfo_All> vBase_ProductInfo_All { get; set; }
        public virtual DbSet<vBase_ProductInfo_Position_Import> vBase_ProductInfo_Position_Import { get; set; }
        public virtual DbSet<vBase_ProductInfo_Provider_Import> vBase_ProductInfo_Provider_Import { get; set; }
        public virtual DbSet<vBase_ProductInfo_SKU> vBase_ProductInfo_SKU { get; set; }
        public virtual DbSet<vBase_ProductInfo_SpecValue> vBase_ProductInfo_SpecValue { get; set; }
        public virtual DbSet<vBase_ProductInfo_Storage> vBase_ProductInfo_Storage { get; set; }
        public virtual DbSet<vBase_ProductInfo_Storage_Report> vBase_ProductInfo_Storage_Report { get; set; }
        public virtual DbSet<vBase_ProductInfo_StorageLower> vBase_ProductInfo_StorageLower { get; set; }
        public virtual DbSet<vBase_ProductInfo_StorageLower_Replenishment> vBase_ProductInfo_StorageLower_Replenishment { get; set; }
        public virtual DbSet<vBase_ProductInfo_StorageUpper> vBase_ProductInfo_StorageUpper { get; set; }
        public virtual DbSet<vBase_ProductInfo_Weight_Import> vBase_ProductInfo_Weight_Import { get; set; }
        public virtual DbSet<vBase_ProductPlaceHolder> vBase_ProductPlaceHolder { get; set; }
        public virtual DbSet<vBase_ProductPosition> vBase_ProductPosition { get; set; }
        public virtual DbSet<vBase_ProductPosition_Lower> vBase_ProductPosition_Lower { get; set; }
        public virtual DbSet<vBase_ProductPosition_Process> vBase_ProductPosition_Process { get; set; }
        public virtual DbSet<vBase_ProductPosition_RealTime> vBase_ProductPosition_RealTime { get; set; }
        public virtual DbSet<vBase_ProductPositionData> vBase_ProductPositionData { get; set; }
        public virtual DbSet<vBase_ProductPositionGroup> vBase_ProductPositionGroup { get; set; }
        public virtual DbSet<vBase_ProductPositionGroup_Position> vBase_ProductPositionGroup_Position { get; set; }
        public virtual DbSet<vBase_ProductSplitGroup> vBase_ProductSplitGroup { get; set; }
        public virtual DbSet<vBase_Provider_Arrears> vBase_Provider_Arrears { get; set; }
        public virtual DbSet<vBase_StorageArea> vBase_StorageArea { get; set; }
        public virtual DbSet<vBase_StorageArea_All> vBase_StorageArea_All { get; set; }
        public virtual DbSet<vBase_StorageArea_Position> vBase_StorageArea_Position { get; set; }
        public virtual DbSet<vBase_StorageArea_Position_History> vBase_StorageArea_Position_History { get; set; }
        public virtual DbSet<vCIQ_HZ_Storage> vCIQ_HZ_Storage { get; set; }
        public virtual DbSet<vCRM_SaleQuotationList> vCRM_SaleQuotationList { get; set; }
        public virtual DbSet<veBay_SKU_Relation_SKU> veBay_SKU_Relation_SKU { get; set; }
        public virtual DbSet<veBay_SKU_Relation_Unmap> veBay_SKU_Relation_Unmap { get; set; }
        public virtual DbSet<vERP_Base_ProductPositionHistory> vERP_Base_ProductPositionHistory { get; set; }
        public virtual DbSet<vERP_Purchase_Enter> vERP_Purchase_Enter { get; set; }
        public virtual DbSet<vERP_Purchase_Enter_YiCheng> vERP_Purchase_Enter_YiCheng { get; set; }
        public virtual DbSet<vERP_Purchase_Order> vERP_Purchase_Order { get; set; }
        public virtual DbSet<vERP_Purchase_Order_YiCheng> vERP_Purchase_Order_YiCheng { get; set; }
        public virtual DbSet<vERP_Sale_Order> vERP_Sale_Order { get; set; }
        public virtual DbSet<vERP_Sale_Order_InOutParkOrderStatus> vERP_Sale_Order_InOutParkOrderStatus { get; set; }
        public virtual DbSet<vERP_Sale_Order_PushSortingStatus> vERP_Sale_Order_PushSortingStatus { get; set; }
        public virtual DbSet<vERP_Sale_Order_YiCheng> vERP_Sale_Order_YiCheng { get; set; }
        public virtual DbSet<vERP_Sale_OrderUpdate_YiCheng> vERP_Sale_OrderUpdate_YiCheng { get; set; }
        public virtual DbSet<vERP_Sale_Return_YiCheng> vERP_Sale_Return_YiCheng { get; set; }
        public virtual DbSet<vExpress_BaseInfo> vExpress_BaseInfo { get; set; }
        public virtual DbSet<vExpress_OrderRoute> vExpress_OrderRoute { get; set; }
        public virtual DbSet<vFee_StatWorkerByMonth> vFee_StatWorkerByMonth { get; set; }
        public virtual DbSet<vFinance_BankAccount> vFinance_BankAccount { get; set; }
        public virtual DbSet<vFinance_BankFeeList> vFinance_BankFeeList { get; set; }
        public virtual DbSet<vFinance_FeeList> vFinance_FeeList { get; set; }
        public virtual DbSet<vFinance_Pay_Purchase_Adjustment> vFinance_Pay_Purchase_Adjustment { get; set; }
        public virtual DbSet<vFinance_Pay_PurchaseList_Adjustment> vFinance_Pay_PurchaseList_Adjustment { get; set; }
        public virtual DbSet<vFinance_Prepay_Surplus> vFinance_Prepay_Surplus { get; set; }
        public virtual DbSet<vFinance_Prereceive_Surplus> vFinance_Prereceive_Surplus { get; set; }
        public virtual DbSet<vFinance_Receive_Adjustment> vFinance_Receive_Adjustment { get; set; }
        public virtual DbSet<vFinance_ReceiveList_Adjustment> vFinance_ReceiveList_Adjustment { get; set; }
        public virtual DbSet<vMagento_Order_Relation> vMagento_Order_Relation { get; set; }
        public virtual DbSet<vMagento_StoreInfo_Site> vMagento_StoreInfo_Site { get; set; }
        public virtual DbSet<VmaterialInfo> VmaterialInfo { get; set; }
        public virtual DbSet<vOldLibraryEarlyWarning> vOldLibraryEarlyWarning { get; set; }
        public virtual DbSet<vPurchase_Enter_RankByDay> vPurchase_Enter_RankByDay { get; set; }
        public virtual DbSet<vPurchase_Enter_RankByMonth> vPurchase_Enter_RankByMonth { get; set; }
        public virtual DbSet<vPurchase_Enter_RankByWeek> vPurchase_Enter_RankByWeek { get; set; }
        public virtual DbSet<vPurchase_Enter_Ranking> vPurchase_Enter_Ranking { get; set; }
        public virtual DbSet<vPurchase_EnterList> vPurchase_EnterList { get; set; }
        public virtual DbSet<vPurchase_EnterList_CreateShelve> vPurchase_EnterList_CreateShelve { get; set; }
        public virtual DbSet<vPurchase_EnterList_Report> vPurchase_EnterList_Report { get; set; }
        public virtual DbSet<vPurchase_ExchangeEnterList> vPurchase_ExchangeEnterList { get; set; }
        public virtual DbSet<vPurchase_ExchangeOuterList> vPurchase_ExchangeOuterList { get; set; }
        public virtual DbSet<vPurchase_Order_Arrived> vPurchase_Order_Arrived { get; set; }
        public virtual DbSet<vPurchase_OrderList> vPurchase_OrderList { get; set; }
        public virtual DbSet<vPurchase_OrderList_Report> vPurchase_OrderList_Report { get; set; }
        public virtual DbSet<vPurchase_ReturnList> vPurchase_ReturnList { get; set; }
        public virtual DbSet<vPurchase_ShelveDetail> vPurchase_ShelveDetail { get; set; }
        public virtual DbSet<vPurchase_ShelveList> vPurchase_ShelveList { get; set; }
        public virtual DbSet<vRequire_AllocationList> vRequire_AllocationList { get; set; }
        public virtual DbSet<vRequire_GoodsList> vRequire_GoodsList { get; set; }
        public virtual DbSet<vSale_ExchangeEnterList> vSale_ExchangeEnterList { get; set; }
        public virtual DbSet<vSale_ExchangeOuterList> vSale_ExchangeOuterList { get; set; }
        public virtual DbSet<vSale_Order> vSale_Order { get; set; }
        public virtual DbSet<vSale_Order_FactFreightRMB> vSale_Order_FactFreightRMB { get; set; }
        public virtual DbSet<vSale_Order_ProductSplit> vSale_Order_ProductSplit { get; set; }
        public virtual DbSet<vSale_Order_ProductSplitList> vSale_Order_ProductSplitList { get; set; }
        public virtual DbSet<vSale_Order_SortPool> vSale_Order_SortPool { get; set; }
        public virtual DbSet<vSale_Order_Stat> vSale_Order_Stat { get; set; }
        public virtual DbSet<vSale_Order_Transfter> vSale_Order_Transfter { get; set; }
        public virtual DbSet<vSale_OrderDetail> vSale_OrderDetail { get; set; }
        public virtual DbSet<vSale_OrderList> vSale_OrderList { get; set; }
        public virtual DbSet<vSale_OrderList_Client> vSale_OrderList_Client { get; set; }
        public virtual DbSet<vSale_OrderList_Lack> vSale_OrderList_Lack { get; set; }
        public virtual DbSet<vSale_OrderList_Replenishment> vSale_OrderList_Replenishment { get; set; }
        public virtual DbSet<vSale_OrderList_Report> vSale_OrderList_Report { get; set; }
        public virtual DbSet<vSale_OrderPickingList> vSale_OrderPickingList { get; set; }
        public virtual DbSet<vSale_OrderPickToLight> vSale_OrderPickToLight { get; set; }
        public virtual DbSet<vSale_OrderPlanDetail> vSale_OrderPlanDetail { get; set; }
        public virtual DbSet<vSale_OrderPrintList> vSale_OrderPrintList { get; set; }
        public virtual DbSet<vSale_OrderPrintList_Group> vSale_OrderPrintList_Group { get; set; }
        public virtual DbSet<vSale_Outer_Case> vSale_Outer_Case { get; set; }
        public virtual DbSet<vSale_Outer_CaseList> vSale_Outer_CaseList { get; set; }
        public virtual DbSet<vSale_Outer_Loading> vSale_Outer_Loading { get; set; }
        public virtual DbSet<vSale_Outer_Loading_Outer> vSale_Outer_Loading_Outer { get; set; }
        public virtual DbSet<vSale_OuterList> vSale_OuterList { get; set; }
        public virtual DbSet<vSale_OuterWrapper> vSale_OuterWrapper { get; set; }
        public virtual DbSet<vSale_RankByDay> vSale_RankByDay { get; set; }
        public virtual DbSet<vSale_RankByMonth> vSale_RankByMonth { get; set; }
        public virtual DbSet<vSale_RankByWeek> vSale_RankByWeek { get; set; }
        public virtual DbSet<vSale_Ranking> vSale_Ranking { get; set; }
        public virtual DbSet<vSale_ReturnList> vSale_ReturnList { get; set; }
        public virtual DbSet<vSale_SendList_Report> vSale_SendList_Report { get; set; }
        public virtual DbSet<vShelfLifeEarlyWarning> vShelfLifeEarlyWarning { get; set; }
        public virtual DbSet<vStat_StorageDay> vStat_StorageDay { get; set; }
        public virtual DbSet<vStorage_AllocateApplyList> vStorage_AllocateApplyList { get; set; }
        public virtual DbSet<vStorage_AssembleOuterList> vStorage_AssembleOuterList { get; set; }
        public virtual DbSet<vStorage_BorrowEnterList> vStorage_BorrowEnterList { get; set; }
        public virtual DbSet<vStorage_BorrowEnterReturnList> vStorage_BorrowEnterReturnList { get; set; }
        public virtual DbSet<vStorage_BorrowOuterList> vStorage_BorrowOuterList { get; set; }
        public virtual DbSet<vStorage_CheckList> vStorage_CheckList { get; set; }
        public virtual DbSet<vStorage_EnterList> vStorage_EnterList { get; set; }
        public virtual DbSet<vStorage_LossList> vStorage_LossList { get; set; }
        public virtual DbSet<vStorage_OuterList> vStorage_OuterList { get; set; }
        public virtual DbSet<vStorage_Plate> vStorage_Plate { get; set; }
        public virtual DbSet<vStorage_PositionTransferList> vStorage_PositionTransferList { get; set; }
        public virtual DbSet<vStorage_ProfitLossList> vStorage_ProfitLossList { get; set; }
        public virtual DbSet<vSys_Menu> vSys_Menu { get; set; }
        public virtual DbSet<vSys_ParamValue> vSys_ParamValue { get; set; }
        public virtual DbSet<vSys_User_Login> vSys_User_Login { get; set; }
        public virtual DbSet<vTaobao_SKU> vTaobao_SKU { get; set; }
        public virtual DbSet<vTMS_Claim> vTMS_Claim { get; set; }
        public virtual DbSet<vTMS_QuotationList> vTMS_QuotationList { get; set; }
        public virtual DbSet<vTMS_TruckInfo_LoadBill> vTMS_TruckInfo_LoadBill { get; set; }
        public virtual DbSet<vTMS_WayBillList> vTMS_WayBillList { get; set; }
        public virtual DbSet<vTMS_WayBillUpload> vTMS_WayBillUpload { get; set; }
        public virtual DbSet<vvBase_ProductPosition> vvBase_ProductPosition { get; set; }
        public virtual DbSet<vWebgistix_Inventory> vWebgistix_Inventory { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<C_WillDel_Base_Consignor_Address>()
                .Property(e => e.Longitude)
                .HasPrecision(18, 5);

            modelBuilder.Entity<C_WillDel_Base_Consignor_Address>()
                .Property(e => e.Latitude)
                .HasPrecision(18, 5);

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

            modelBuilder.Entity<Adjustment_Client_BatchList>()
                .Property(e => e.AdjustMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Adjustment_Provider_BatchList>()
                .Property(e => e.AdjustMoney)
                .HasPrecision(19, 4);

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

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

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

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

            modelBuilder.Entity<AliExpress_Logistics>()
                .Property(e => e.TrackingNoRegex)
                .IsFixedLength();

            modelBuilder.Entity<AliExpress_Order_Fulfillment>()
                .Property(e => e.Description)
                .IsUnicode(false);

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

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

            modelBuilder.Entity<AliExpress_Product>()
                .Property(e => e.GrossWeight)
                .HasPrecision(18, 3);

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

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

            modelBuilder.Entity<AliExpress_Product_Variation>()
                .Property(e => e.SkuPrice)
                .HasPrecision(19, 4);

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

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

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

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

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

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

            modelBuilder.Entity<AliExpress_SaleOrder>()
                .HasMany(e => e.AliExpress_SaleOrderList)
                .WithOptional(e => e.AliExpress_SaleOrder)
                .WillCascadeOnDelete();

            modelBuilder.Entity<AliExpress_StoreInfo>()
                .Property(e => e.AppKey)
                .IsUnicode(false);

            modelBuilder.Entity<AliExpress_StoreInfo>()
                .Property(e => e.AppSecret)
                .IsUnicode(false);

            modelBuilder.Entity<AliExpress_StoreInfo>()
                .Property(e => e.AccessToken)
                .IsUnicode(false);

            modelBuilder.Entity<AliExpress_StoreInfo>()
                .Property(e => e.MerchantAccount)
                .IsUnicode(false);

            modelBuilder.Entity<AliExpress_StoreInfo>()
                .Property(e => e.MerchantKey)
                .IsUnicode(false);

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

            modelBuilder.Entity<AliExpress_StoreInfo>()
                .Property(e => e.PlatformCommission)
                .HasPrecision(18, 4);

            modelBuilder.Entity<AliExpress_StoreInfo>()
                .Property(e => e.PayalCommission)
                .HasPrecision(18, 4);

            modelBuilder.Entity<AliExpress_StoreInfo>()
                .Property(e => e.ExchangeRMB)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.CurrencyCode)
                .IsUnicode(false);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.MSRP)
                .HasPrecision(12, 2);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.RegularPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.ListingPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.ShippingPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.ShippingWeight)
                .HasPrecision(12, 2);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.Length)
                .HasPrecision(12, 2);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.Width)
                .HasPrecision(12, 2);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.Height)
                .HasPrecision(12, 2);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.Weight)
                .HasPrecision(12, 2);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.PackageLength)
                .HasPrecision(12, 2);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.PackageWidth)
                .HasPrecision(12, 2);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.PackageHeight)
                .HasPrecision(12, 2);

            modelBuilder.Entity<Amazon_Product>()
                .Property(e => e.PackageWeight)
                .HasPrecision(12, 2);

            modelBuilder.Entity<Amazon_Product>()
                .HasMany(e => e.Amazon_Product_ItemValue)
                .WithRequired(e => e.Amazon_Product)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Amazon_SaleOrder>()
                .Property(e => e.OrderTotal_Amount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_SaleOrder>()
                .Property(e => e.OrderPaymentCODAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_SaleOrder>()
                .Property(e => e.OrderPaymentGCAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_SaleOrderList>()
                .Property(e => e.ItemPriceAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_SaleOrderList>()
                .Property(e => e.ShippingPriceAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_SaleOrderList>()
                .Property(e => e.GiftWrapPriceAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_SaleOrderList>()
                .Property(e => e.ItemTaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_SaleOrderList>()
                .Property(e => e.ShippingTaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_SaleOrderList>()
                .Property(e => e.GiftWrapTaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_SaleOrderList>()
                .Property(e => e.ShippingDiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_SaleOrderList>()
                .Property(e => e.PromotionDiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_SaleOrderList>()
                .Property(e => e.CODFeeAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_SaleOrderList>()
                .Property(e => e.CODFeeDiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_StoreInfo>()
                .Property(e => e.AmazonAccessKeyId)
                .IsUnicode(false);

            modelBuilder.Entity<Amazon_StoreInfo>()
                .Property(e => e.AmazonSecretAccessKey)
                .IsUnicode(false);

            modelBuilder.Entity<Amazon_StoreInfo>()
                .Property(e => e.AmazonMarketplaceId)
                .IsUnicode(false);

            modelBuilder.Entity<Amazon_StoreInfo>()
                .Property(e => e.AmazonMerchantId)
                .IsUnicode(false);

            modelBuilder.Entity<Amazon_StoreInfo>()
                .Property(e => e.ServiceURL)
                .IsUnicode(false);

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

            modelBuilder.Entity<Amazon_StoreInfo>()
                .Property(e => e.PlatformCommission)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Amazon_StoreInfo>()
                .Property(e => e.PayalCommission)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Amazon_StoreInfo>()
                .Property(e => e.ExchangeRMB)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Amazon_StoreInfo>()
                .HasMany(e => e.Amazon_Product)
                .WithOptional(e => e.Amazon_StoreInfo)
                .WillCascadeOnDelete();

            modelBuilder.Entity<API_PurchaseOrder_Feedback>()
                .HasMany(e => e.API_PurchaseOrder_FeedbackList)
                .WithOptional(e => e.API_PurchaseOrder_Feedback)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Base_Brand>()
                .Property(e => e.Logo)
                .IsUnicode(false);

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

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

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

            modelBuilder.Entity<Base_Client>()
                .Property(e => e.CreditLine)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_Client>()
                .Property(e => e.CorpURL)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Client>()
                .Property(e => e.BankCode)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Client>()
                .Property(e => e.RaxCode)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Client>()
                .Property(e => e.ArtificiaPerson)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Client>()
                .Property(e => e.MonthSales)
                .IsUnicode(false);

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

            modelBuilder.Entity<Base_Consignor>()
                .Property(e => e.BankCode)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Consignor>()
                .Property(e => e.RaxCode)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Consignor>()
                .Property(e => e.CorpURL)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Consignor>()
                .Property(e => e.Email)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Consignor>()
                .Property(e => e.ArtificiaPerson)
                .IsUnicode(false);

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

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

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

            modelBuilder.Entity<Base_ConsignorAddress>()
                .Property(e => e.Longitude)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Base_ConsignorAddress>()
                .Property(e => e.Latitude)
                .HasPrecision(18, 5);

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

            modelBuilder.Entity<Base_ConsignorContract>()
                .Property(e => e.StorageRate)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_ConsignorContract>()
                .Property(e => e.DeliveryRate)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_ConsignorContract>()
                .Property(e => e.FlowRate)
                .HasPrecision(18, 4);

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

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

            modelBuilder.Entity<Base_ConsignorStoreAddress>()
                .Property(e => e.Longitude)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_ConsignorStoreAddress>()
                .Property(e => e.Latitude)
                .HasPrecision(18, 4);

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

            modelBuilder.Entity<Base_Country>()
                .Property(e => e.DigitalCode)
                .IsFixedLength();

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

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

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

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

            modelBuilder.Entity<Base_EmptyEquipment>()
                .Property(e => e.DemandQuantity)
                .HasPrecision(14, 4);

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

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

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

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

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

            modelBuilder.Entity<Base_EmptyEquipmentReturn>()
                .HasOptional(e => e.Base_EmptyEquipmentReturn1)
                .WithRequired(e => e.Base_EmptyEquipmentReturn2);

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

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

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

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

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

            modelBuilder.Entity<Base_ExpressCorp>()
                .Property(e => e.DeclareRate)
                .HasPrecision(18, 3);

            modelBuilder.Entity<Base_ExpressCorp>()
                .Property(e => e.MinDeclareValue)
                .HasPrecision(18, 3);

            modelBuilder.Entity<Base_ExpressCorp>()
                .Property(e => e.MaxDeclareValue)
                .HasPrecision(18, 3);

            modelBuilder.Entity<Base_FreightDiscount>()
                .Property(e => e.Discount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_FreightPartition>()
                .Property(e => e.CounterFee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_FreightPrice>()
                .Property(e => e.FirstExpenses)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_FreightPrice>()
                .Property(e => e.ContinuedExpense)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_FreightPrice>()
                .Property(e => e.ExpenseKg50)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_FreightPrice>()
                .Property(e => e.ExpenseKg51)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_FreightPrice>()
                .Property(e => e.CounterFee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_FreightTemplate>()
                .Property(e => e.FuelCostRatio)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_FreightTemplate>()
                .Property(e => e.PayableFeeRatio)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ImageConfig>()
                .Property(e => e.Remark1)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Order_Statistics>()
                .Property(e => e.TotalSales)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_Order_Statistics>()
                .Property(e => e.EffectiveSales)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_Order_Statistics>()
                .Property(e => e.InvalidSales)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_Park>()
                .Property(e => e.Longitude)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_Park>()
                .Property(e => e.Latitude)
                .HasPrecision(18, 4);

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

            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<Base_PlateType>()
                .Property(e => e.PlateCode)
                .IsUnicode(false);

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

            modelBuilder.Entity<Base_Position>()
                .Property(e => e.PlateCode)
                .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<Base_PrintTemplate>()
                .Property(e => e.VueData)
                .IsUnicode(false);

            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<Base_ProductInfo_Image>()
                .Property(e => e.Creator)
                .IsUnicode(false);

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

            modelBuilder.Entity<Base_ProductInfo_Image>()
                .Property(e => e.DeleteBy)
                .IsUnicode(false);

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

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<Base_ProductInfo_Storage>()
                .Property(e => e.DamagedPurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductInfo_Storage>()
                .Property(e => e.DamagedPurchaseMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Base_ProductInfo_Storage>()
                .Property(e => e.SaleMoney)
                .HasPrecision(19, 4);

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

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

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

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

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

            modelBuilder.Entity<Base_ProductPlaceHolder>()
                .Property(e => e.PlaceholderStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPlaceHolder>()
                .Property(e => e.OrignHolderStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPlaceHolder>()
                .Property(e => e.PlaceholderWeight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Base_ProductPlaceHolder>()
                .Property(e => e.OrignHolderWeight)
                .HasPrecision(18, 6);

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

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

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

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

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

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

            modelBuilder.Entity<Base_ProductPlaceHolder_Bak>()
                .Property(e => e.PlaceholderStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPlaceHolder_Bak>()
                .Property(e => e.OrignHolderStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPlaceHolder_Bak>()
                .Property(e => e.UsedStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPlaceHolder_Bak>()
                .Property(e => e.UnouterStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPlaceHolder_Bak>()
                .Property(e => e.PlaceholderWeight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Base_ProductPlaceHolder_Bak>()
                .Property(e => e.OrignHolderWeight)
                .HasPrecision(18, 6);

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

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

            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<Base_ProductPositionHistory>()
                .Property(e => e.InQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPositionHistory>()
                .Property(e => e.OutQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPositionHistory>()
                .Property(e => e.InMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductPositionHistory>()
                .Property(e => e.OutMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductPositionHistory>()
                .Property(e => e.BeforeQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPositionHistory>()
                .Property(e => e.AfterQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Base_ProductPositionHistory>()
                .Property(e => e.AfterMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_ProductPositionHistory>()
                .Property(e => e.InWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Base_ProductPositionHistory>()
                .Property(e => e.OutWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Base_ProductPositionHistory>()
                .Property(e => e.BeforeWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<Base_ProductPositionHistory>()
                .Property(e => e.AfterWeight)
                .HasPrecision(18, 5);

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

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

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

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

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

            modelBuilder.Entity<Base_ProductSet>()
                .HasOptional(e => e.Base_ProductSet1)
                .WithRequired(e => e.Base_ProductSet2);

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

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

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

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

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

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.BankCode)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.RaxCode)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.CorpURL)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.Email)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.ArtificiaPerson)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.AccountsMode)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.AccountsPeriod)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.CreditLine)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.EnpterType)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.EnpterMode)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.TicketType)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.CooperationMode)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.FanDianFee)
                .IsUnicode(false);

            modelBuilder.Entity<Base_Provider>()
                .Property(e => e.ProductDiscount)
                .IsUnicode(false);

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

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

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

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

            modelBuilder.Entity<Base_ProviderContract>()
                .Property(e => e.TaxPoint)
                .HasPrecision(18, 4);

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

            modelBuilder.Entity<Base_ProviderUser>()
                .Property(e => e.UserTrueName)
                .IsFixedLength();

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

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

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

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

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

            modelBuilder.Entity<Base_SortingCloutReturn>()
                .Property(e => e.CompleteQuantity)
                .HasPrecision(14, 4);

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

            modelBuilder.Entity<Base_SortingCloutReturn>()
                .HasMany(e => e.Base_SortingCloutReturnList)
                .WithOptional(e => e.Base_SortingCloutReturn)
                .WillCascadeOnDelete();

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

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

            modelBuilder.Entity<Base_SortingCloutReturnList>()
                .Property(e => e.CompleteQuantity)
                .HasPrecision(14, 4);

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

            modelBuilder.Entity<Base_SortingCloutReturnList>()
                .Property(e => e.Weight)
                .HasPrecision(14, 4);

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

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

            modelBuilder.Entity<Base_Specification>()
                .HasMany(e => e.Base_SpecificationValue)
                .WithOptional(e => e.Base_Specification)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Base_Staff>()
                .Property(e => e.Notes)
                .IsUnicode(false);

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

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

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

            modelBuilder.Entity<Base_Staff>()
                .Property(e => e.IdlenessRisk)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_Staff>()
                .Property(e => e.AgedRisk)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_Staff>()
                .Property(e => e.MedicalRisk)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_Staff>()
                .Property(e => e.CopmoRisk)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_Staff>()
                .Property(e => e.BearingRisk)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Base_Staff>()
                .Property(e => e.HousingSubsidy)
                .HasPrecision(19, 4);

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

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

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

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

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

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

            modelBuilder.Entity<Base_Storage_Region>()
                .Property(e => e.DeleteBy)
                .IsUnicode(false);

            modelBuilder.Entity<Base_StorageArea>()
                .Property(e => e.MaxWeight)
                .HasPrecision(14, 2);

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

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

            modelBuilder.Entity<Base_StorageLease>()
                .Property(e => e.UnitPrice)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_StorageLease>()
                .Property(e => e.TotalPrice)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_StorageLease>()
                .Property(e => e.PaidPrice)
                .HasPrecision(18, 4);

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

            modelBuilder.Entity<Base_StorageTemperature>()
                .Property(e => e.Temperature)
                .HasPrecision(18, 1);

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

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

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

            modelBuilder.Entity<Base_TruckFee>()
                .HasMany(e => e.TMS_TruckFeeList)
                .WithOptional(e => e.Base_TruckFee)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Base_TruckInfo>()
                .Property(e => e.Volume)
                .HasPrecision(18, 0);

            modelBuilder.Entity<Base_Vehicle>()
                .Property(e => e.Vehicleload)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_Vehicle>()
                .Property(e => e.VehicleVolume)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_Vehicle>()
                .Property(e => e.CarLength)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_Vehicle>()
                .Property(e => e.CarWidth)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_Vehicle>()
                .Property(e => e.CarHeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_Vehicle>()
                .Property(e => e.ResidualRate)
                .HasPrecision(18, 4);

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

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

            modelBuilder.Entity<CIQ_HZ_ContrastResult>()
                .Property(e => e.divergenceNumA)
                .HasPrecision(18, 0);

            modelBuilder.Entity<CIQ_HZ_ContrastResult>()
                .Property(e => e.divergenceNumB)
                .HasPrecision(18, 0);

            modelBuilder.Entity<CIQ_HZ_ContrastResult>()
                .HasMany(e => e.CIQ_HZ_ContrastResultList)
                .WithRequired(e => e.CIQ_HZ_ContrastResult)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CIQ_HZ_InFactList>()
                .Property(e => e.itemNo)
                .HasPrecision(18, 0);

            modelBuilder.Entity<CIQ_HZ_InFactList>()
                .Property(e => e.receiveAmount)
                .HasPrecision(15, 5);

            modelBuilder.Entity<CIQ_HZ_InOrder>()
                .Property(e => e.grossWeight)
                .HasPrecision(15, 5);

            modelBuilder.Entity<CIQ_HZ_InOrder>()
                .Property(e => e.netWeight)
                .HasPrecision(15, 5);

            modelBuilder.Entity<CIQ_HZ_InOrderList>()
                .Property(e => e.declareAmount)
                .HasPrecision(15, 5);

            modelBuilder.Entity<CIQ_HZ_InOrderList>()
                .Property(e => e.totalPrice)
                .HasPrecision(15, 5);

            modelBuilder.Entity<CIQ_HZ_InOrderList>()
                .Property(e => e.price)
                .HasPrecision(15, 5);

            modelBuilder.Entity<CIQ_HZ_InOrderList>()
                .Property(e => e.grossWeight)
                .HasPrecision(15, 5);

            modelBuilder.Entity<CIQ_HZ_InOrderList>()
                .Property(e => e.netWeight)
                .HasPrecision(15, 5);

            modelBuilder.Entity<CIQ_HZ_InOutContrast>()
                .Property(e => e.totalNum)
                .HasPrecision(18, 0);

            modelBuilder.Entity<CIQ_HZ_InOutContrast>()
                .Property(e => e.currentNum)
                .HasPrecision(18, 0);

            modelBuilder.Entity<CIQ_HZ_InOutContrast>()
                .HasMany(e => e.CIQ_HZ_InOutContrastList)
                .WithRequired(e => e.CIQ_HZ_InOutContrast)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CIQ_HZ_OutInOrderList>()
                .Property(e => e.inOutAmount)
                .HasPrecision(15, 5);

            modelBuilder.Entity<CIQ_HZ_ReceiptInfo>()
                .HasMany(e => e.CIQ_HZ_ReceiptDetail)
                .WithRequired(e => e.CIQ_HZ_ReceiptInfo)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CIQ_HZ_StockDeleteResult>()
                .HasMany(e => e.CIQ_HZ_StockDeleteResultList)
                .WithRequired(e => e.CIQ_HZ_StockDeleteResult)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<CIQ_HZ_StorageInfoList>()
                .Property(e => e.goodsQuantity)
                .HasPrecision(15, 5);

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.companyCode)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.businessNo)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.businessType)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.declareType)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.note)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.orderNo)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.eCommerceCode)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payTransactionNo)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payMerchantCode)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payAmount)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payAmountCurr)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payGoodsAmount)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payGoodsAmountCurr)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payTaxAmount)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payTaxAmountCurr)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.freight)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.freightCurr)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payTimeStr)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payEnterpriseName)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payEnterpriseCode)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.bank)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.assoBankAccount)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payAccount)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payerName)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payerDocumentType)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payerDocumentNumber)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_ImportPay>()
                .Property(e => e.payerPhoneNumber)
                .IsFixedLength();

            modelBuilder.Entity<CIQ_NB_OutFeedbackList>()
                .Property(e => e.qty)
                .HasPrecision(10, 3);

            modelBuilder.Entity<CIQ_NB_ProductInfo>()
                .Property(e => e.Cube)
                .HasPrecision(18, 3);

            modelBuilder.Entity<CIQ_NB_ProductInfo>()
                .Property(e => e.Swt)
                .HasPrecision(18, 3);

            modelBuilder.Entity<CIQ_NB_PurchaseOrder_UpList>()
                .Property(e => e.QtyQp)
                .HasPrecision(10, 3);

            modelBuilder.Entity<CIQ_NB_PurchaseOrder_UpList>()
                .Property(e => e.QtyDef)
                .HasPrecision(10, 3);

            modelBuilder.Entity<CIQ_NB_PurchaseOrderList>()
                .Property(e => e.Qty)
                .HasPrecision(10, 3);

            modelBuilder.Entity<CIQ_NB_PurchaseOrderList>()
                .Property(e => e.CurrencyValue)
                .HasPrecision(10, 3);

            modelBuilder.Entity<CIQ_NB_SaleOrder>()
                .Property(e => e.Payment)
                .HasPrecision(10, 3);

            modelBuilder.Entity<CIQ_NB_SaleOrder>()
                .HasMany(e => e.CIQ_NB_SaleOrderList)
                .WithOptional(e => e.CIQ_NB_SaleOrder)
                .WillCascadeOnDelete();

            modelBuilder.Entity<CIQ_NB_SaleOrder_Out>()
                .Property(e => e.tdq)
                .HasPrecision(10, 3);

            modelBuilder.Entity<CIQ_NB_SaleOrder_OutList>()
                .Property(e => e.ExpectedQty)
                .HasPrecision(10, 3);

            modelBuilder.Entity<CIQ_NB_SaleOrderConfirm>()
                .Property(e => e.tdq)
                .HasPrecision(10, 3);

            modelBuilder.Entity<CIQ_NB_SaleOrderList>()
                .Property(e => e.TaxPrice)
                .HasPrecision(22, 5);

            modelBuilder.Entity<CIQ_NB_SaleOrderList>()
                .Property(e => e.ExpectedQty)
                .HasPrecision(10, 3);

            modelBuilder.Entity<CIQ_Order>()
                .Property(e => e.OrderGoodTotal)
                .HasPrecision(18, 4);

            modelBuilder.Entity<CIQ_Order>()
                .Property(e => e.Freight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<CIQ_Order>()
                .Property(e => e.Tax)
                .HasPrecision(18, 4);

            modelBuilder.Entity<CIQ_OrderList>()
                .Property(e => e.DecPrice)
                .HasPrecision(18, 4);

            modelBuilder.Entity<CIQ_OrderList>()
                .Property(e => e.DeclTotal)
                .HasPrecision(18, 4);

            modelBuilder.Entity<CMS_Content>()
                .Property(e => e.DiscountInfo)
                .IsUnicode(false);

            modelBuilder.Entity<CMS_Content>()
                .Property(e => e.TopicType)
                .IsUnicode(false);

            modelBuilder.Entity<CMS_Content>()
                .HasMany(e => e.CMS_Content_ProductDetail)
                .WithOptional(e => e.CMS_Content)
                .WillCascadeOnDelete();

            modelBuilder.Entity<CMS_Content>()
                .HasMany(e => e.CMS_Content_ProductLibDetail)
                .WithOptional(e => e.CMS_Content)
                .WillCascadeOnDelete();

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

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

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

            modelBuilder.Entity<CMS_Module>()
                .Property(e => e.ModuleTemplate)
                .IsUnicode(false);

            modelBuilder.Entity<CMS_Module>()
                .Property(e => e.PreviewPic)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Decl_Byorder>()
                .Property(e => e.CustomsCode)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Decl_Byorder>()
                .Property(e => e.OrgName)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Decl_Byorder>()
                .Property(e => e.MftNo)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Decl_Byorder>()
                .Property(e => e.OrderNo)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Decl_Byorder>()
                .Property(e => e.LogisticsNo)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Decl_Byorder>()
                .Property(e => e.CheckFlg)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Decl_Byorder>()
                .Property(e => e.CheckMsg)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Decl_Byorder>()
                .Property(e => e.Status)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Decl_Byorder>()
                .Property(e => e.Result)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.CustomsCode)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.OrgName)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.Operation)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.MftNo)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.OrderShop)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.OTOCode)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.OrderFrom)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.PackageFlag)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.OrderNo)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.PostFee)
                .HasPrecision(19, 3);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.Amount)
                .HasPrecision(19, 3);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.BuyerAccount)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.Phone)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.Email)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.TaxAmount)
                .HasPrecision(19, 3);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.DisAmount)
                .HasPrecision(19, 3);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.PaymentNo)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.OrderSeqNo)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.Source)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.Idnum)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.Name)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.LogisticsNo)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.LogisticsName)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.Consignee)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.Province)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.City)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.District)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.ConsigneeAddr)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.ConsigneeTel)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.MailNo)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Order>()
                .Property(e => e.GoodsName)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_OrderList>()
                .Property(e => e.ProductId)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_OrderList>()
                .Property(e => e.GoodsName)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_OrderList>()
                .Property(e => e.Qty)
                .HasPrecision(19, 3);

            modelBuilder.Entity<Cnec_jh_OrderList>()
                .Property(e => e.Unit)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_OrderList>()
                .Property(e => e.Price)
                .HasPrecision(19, 3);

            modelBuilder.Entity<Cnec_jh_OrderList>()
                .Property(e => e.Amount)
                .HasPrecision(19, 3);

            modelBuilder.Entity<Cnec_jh_OrderList>()
                .Property(e => e.ProAmount)
                .HasPrecision(19, 3);

            modelBuilder.Entity<Cnec_jh_OrderList>()
                .Property(e => e.ProRemark)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Pay>()
                .Property(e => e.CustomsCode)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Pay>()
                .Property(e => e.OrgName)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Pay>()
                .Property(e => e.MftNo)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Pay>()
                .Property(e => e.PaymentNo)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Pay>()
                .Property(e => e.OrderSeqNo)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Pay>()
                .Property(e => e.Amount)
                .HasPrecision(19, 3);

            modelBuilder.Entity<Cnec_jh_Pay>()
                .Property(e => e.CurrCode)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Pay>()
                .Property(e => e.Source)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Pay>()
                .Property(e => e.Idnum)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Pay>()
                .Property(e => e.Name)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Pay>()
                .Property(e => e.Phone)
                .IsUnicode(false);

            modelBuilder.Entity<Cnec_jh_Pay>()
                .Property(e => e.Email)
                .IsUnicode(false);

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

            modelBuilder.Entity<CRM_ClientLinker>()
                .Property(e => e.Email)
                .IsUnicode(false);

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

            modelBuilder.Entity<CRM_ClientLinker>()
                .HasMany(e => e.CRM_ClientLinkerRemind)
                .WithOptional(e => e.CRM_ClientLinker)
                .WillCascadeOnDelete();

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

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

            modelBuilder.Entity<CRM_ClientService>()
                .Property(e => e.Feedback)
                .IsFixedLength();

            modelBuilder.Entity<CRM_ClientService>()
                .Property(e => e.ServiceContent)
                .IsFixedLength();

            modelBuilder.Entity<CRM_Competitor>()
                .Property(e => e.CompetitivePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<CRM_QALibType>()
                .HasMany(e => e.CRM_QALib)
                .WithRequired(e => e.CRM_QALibType)
                .WillCascadeOnDelete(false);

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

            modelBuilder.Entity<CRM_SaleChance>()
                .Property(e => e.PredictMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<CRM_SaleChanceList>()
                .Property(e => e.SaleMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<CRM_SaleCost>()
                .Property(e => e.CostMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<CRM_SaleQuotation>()
                .Property(e => e.TotalSaleMoney)
                .HasPrecision(19, 4);

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

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

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

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

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

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

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

            modelBuilder.Entity<deviceGeneralInfo>()
                .Property(e => e.deviceRunTime)
                .HasPrecision(18, 0);

            modelBuilder.Entity<deviceGeneralInfo>()
                .Property(e => e.deviceWaitTime)
                .HasPrecision(18, 0);

            modelBuilder.Entity<deviceGeneralInfo>()
                .Property(e => e.deviceAlarmTime)
                .HasPrecision(18, 0);

            modelBuilder.Entity<eBay_Message>()
                .Property(e => e.Text)
                .IsUnicode(false);

            modelBuilder.Entity<eBay_Message>()
                .Property(e => e.ForwardDetails)
                .IsUnicode(false);

            modelBuilder.Entity<eBay_Message>()
                .Property(e => e.MsgContent)
                .IsUnicode(false);

            modelBuilder.Entity<eBay_Message>()
                .HasMany(e => e.eBay_Message_Reply)
                .WithRequired(e => e.eBay_Message)
                .HasForeignKey(e => e.ReMessage_Id);

            modelBuilder.Entity<eBay_Order_Relation>()
                .Property(e => e.AdjustmentAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<eBay_Order_Relation>()
                .Property(e => e.AmountPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<eBay_Order_Relation>()
                .Property(e => e.AmountSaved)
                .HasPrecision(19, 4);

            modelBuilder.Entity<eBay_Order_Relation>()
                .Property(e => e.ShippingDetails_ShippingServiceCost)
                .HasPrecision(19, 4);

            modelBuilder.Entity<eBay_Order_Relation>()
                .Property(e => e.Subtotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<eBay_Order_Relation>()
                .Property(e => e.Total)
                .HasPrecision(19, 4);

            modelBuilder.Entity<eBay_OrderList_Relation>()
                .Property(e => e.TransactionPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<eBay_OrderList_Relation>()
                .Property(e => e.ActualShippingCost)
                .HasPrecision(19, 4);

            modelBuilder.Entity<eBay_OrderList_Relation>()
                .Property(e => e.ActualHandlingCost)
                .HasPrecision(19, 4);

            modelBuilder.Entity<eBay_SKU_Relation>()
                .Property(e => e.Description)
                .IsUnicode(false);

            modelBuilder.Entity<eBay_SKU_Relation>()
                .Property(e => e.ShipToLocations)
                .IsUnicode(false);

            modelBuilder.Entity<eBay_SKU_Relation>()
                .HasMany(e => e.eBay_SKU_ListingDetails)
                .WithRequired(e => e.eBay_SKU_Relation)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<eBay_SKU_VariationItem>()
                .Property(e => e.StartPrice_Value)
                .HasPrecision(19, 4);

            modelBuilder.Entity<eBay_SKU_VariationItem>()
                .Property(e => e.UnitCost_Value)
                .HasPrecision(19, 4);

            modelBuilder.Entity<eBay_StoreInfo>()
                .Property(e => e.PlatformCommission)
                .HasPrecision(18, 4);

            modelBuilder.Entity<eBay_StoreInfo>()
                .Property(e => e.PayalCommission)
                .HasPrecision(18, 4);

            modelBuilder.Entity<eBay_StoreInfo>()
                .Property(e => e.ExchangeRMB)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Express_Country_DeclaredValueRegular>()
                .Property(e => e.ReferenceUnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Express_Country_DeclaredValueRegular>()
                .Property(e => e.MaxDeclaredValue)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Express4PX_DeclareInvoice>()
                .Property(e => e.UnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressCK1_RegionCountry_Relation>()
                .Property(e => e.CountryCode)
                .IsFixedLength();

            modelBuilder.Entity<ExpressEasyPost_Order>()
                .Property(e => e.DeclareValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressEbayEUB_OrderList>()
                .Property(e => e.ReceivedAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressEbayEUB_OrderList>()
                .Property(e => e.SoldPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressEbayEUB_OrderList>()
                .Property(e => e.DeclaredValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressEMS_Order>()
                .Property(e => e.declared_value)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressEMS_Order>()
                .Property(e => e.cargo_total_weight)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressEMS_Order>()
                .Property(e => e.cargo_length)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressEMS_Order>()
                .Property(e => e.cargo_width)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressEMS_Order>()
                .Property(e => e.cargo_height)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressEMS_Order>()
                .Property(e => e.volume)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressEUB_Order>()
                .Property(e => e.DeclareValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressQZPort_Order>()
                .Property(e => e.declared_value)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressQZPort_Order>()
                .Property(e => e.cargo_total_weight)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressQZPort_Order>()
                .Property(e => e.cargo_length)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressQZPort_Order>()
                .Property(e => e.cargo_width)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressQZPort_Order>()
                .Property(e => e.cargo_height)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressQZPort_Order>()
                .Property(e => e.volume)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressSF_Order>()
                .Property(e => e.declared_value)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressSF_Order>()
                .Property(e => e.cargo_total_weight)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressSF_Order>()
                .Property(e => e.cargo_length)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressSF_Order>()
                .Property(e => e.cargo_width)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressSF_Order>()
                .Property(e => e.cargo_height)
                .HasPrecision(15, 3);

            modelBuilder.Entity<ExpressSF_Order>()
                .Property(e => e.volume)
                .HasPrecision(15, 3);

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

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

            modelBuilder.Entity<ExpressSharpCentury_OrderList>()
                .Property(e => e.CdValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressShipStation_Carrier>()
                .HasMany(e => e.ExpressShipStation_ShippingService)
                .WithOptional(e => e.ExpressShipStation_Carrier)
                .HasForeignKey(e => e.CarrierID);

            modelBuilder.Entity<ExpressShipStation_Order>()
                .Property(e => e.OrderTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressShipStation_Order>()
                .Property(e => e.AmountPaid)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<ExpressShipStation_OrderList>()
                .Property(e => e.UnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressShipStation_OrderList>()
                .Property(e => e.ExtendedPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressShipStation_OrderList>()
                .Property(e => e.UnitCost)
                .HasPrecision(19, 4);

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

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

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

            modelBuilder.Entity<ExpressStamps_Order>()
                .Property(e => e.DeclareValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressStamps_Order>()
                .Property(e => e.Url)
                .IsUnicode(false);

            modelBuilder.Entity<ExpressStandardEUB_Order>()
                .Property(e => e.DeclareValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressStandardEUB_OrderList>()
                .Property(e => e.delcarevalue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressUPS_Order>()
                .Property(e => e.Url)
                .IsUnicode(false);

            modelBuilder.Entity<ExpressUPS_Order>()
                .Property(e => e.TransportationValue)
                .HasPrecision(18, 3);

            modelBuilder.Entity<ExpressUPS_Order>()
                .Property(e => e.ServiceValue)
                .HasPrecision(18, 3);

            modelBuilder.Entity<ExpressUPS_Order>()
                .Property(e => e.TotalValue)
                .HasPrecision(18, 3);

            modelBuilder.Entity<ExpressUPS_Order>()
                .Property(e => e.ResponseWeight)
                .HasPrecision(18, 3);

            modelBuilder.Entity<ExpressWinit_Order>()
                .Property(e => e.Repeatable)
                .IsFixedLength();

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

            modelBuilder.Entity<ExpressWinit_Sku_Relation>()
                .Property(e => e.InportDeclaredvalue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressWinit_Sku_Relation>()
                .Property(e => e.ExportDeclaredvalue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressYT_Order>()
                .Property(e => e.goodsValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressYT_Order>()
                .Property(e => e.totalValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressYT_Order>()
                .Property(e => e.itemsValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressYT_Order>()
                .Property(e => e.itemsWeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<ExpressYT_Order>()
                .Property(e => e.insuranceValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressYT_Order>()
                .Property(e => e.totalServiceFee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressYT_Order>()
                .Property(e => e.codSplitFee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<ExpressZT_Order>()
                .Property(e => e.price)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeByArea>()
                .Property(e => e.UsedArea)
                .HasPrecision(18, 3);

            modelBuilder.Entity<Fee_ChargeByArea>()
                .Property(e => e.SquarePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeByArea>()
                .Property(e => e.TotalPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeByPeriod>()
                .Property(e => e.TotalPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeByPiece>()
                .Property(e => e.UnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeByPiece>()
                .Property(e => e.TotalPrice)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Fee_ChargeByPosition>()
                .Property(e => e.PositionUnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeByPosition>()
                .Property(e => e.TotalPrice)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Fee_ChargeByPublicArea>()
                .Property(e => e.PublicArea)
                .HasPrecision(18, 3);

            modelBuilder.Entity<Fee_ChargeByPublicArea>()
                .Property(e => e.PublicUnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeByPublicArea>()
                .Property(e => e.TotalPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeConsignorInfo>()
                .Property(e => e.PublicArea)
                .HasPrecision(18, 3);

            modelBuilder.Entity<Fee_ChargeConsignorInfo>()
                .Property(e => e.UsedArea)
                .HasPrecision(18, 3);

            modelBuilder.Entity<Fee_ChargeConsignorInfo>()
                .Property(e => e.PublicAreaPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeConsignorInfo>()
                .Property(e => e.PositionPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeConsignorInfo>()
                .Property(e => e.PiecePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeConsignorInfo>()
                .Property(e => e.SquarePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeInfo>()
                .Property(e => e.PublicArea)
                .HasPrecision(18, 3);

            modelBuilder.Entity<Fee_ChargeInfo>()
                .Property(e => e.PublicAreaPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeInfo>()
                .Property(e => e.PositionPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeInfo>()
                .Property(e => e.PiecePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeInfo>()
                .Property(e => e.SquarePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ChargeType>()
                .Property(e => e.UnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ItemByDay>()
                .Property(e => e.UnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ItemByDay>()
                .Property(e => e.TotalPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ItemConsignorInfo>()
                .Property(e => e.UnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_ItemInfo>()
                .Property(e => e.UnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_MonthBill>()
                .Property(e => e.TotalPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_OtherRecord>()
                .Property(e => e.UnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_OtherRecord>()
                .Property(e => e.TotalPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_PayableBill>()
                .Property(e => e.TotalReceivable)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_PayableBill>()
                .Property(e => e.TotalPaid)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_PayableBill>()
                .HasMany(e => e.Fee_PayableBillDetail)
                .WithOptional(e => e.Fee_PayableBill)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Fee_PayableBillDetail>()
                .Property(e => e.Receivable)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_PayableBillDetail>()
                .Property(e => e.Paid)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_PayableBillDetail>()
                .Property(e => e.UnPaid)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_PayableBillDetail>()
                .Property(e => e.Weight)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_PayableBillDetail>()
                .Property(e => e.FreeMoney)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_PayableBillDetail>()
                .Property(e => e.FeeRate)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_Statement>()
                .Property(e => e.TotalMoney)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_Statement>()
                .HasMany(e => e.Fee_StatementDetail)
                .WithOptional(e => e.Fee_Statement)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Fee_StatementDetail>()
                .Property(e => e.Receivable)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_StatementDetail>()
                .Property(e => e.FreeMoney)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_StatementDetail>()
                .Property(e => e.TagWeight_T)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_StatementDetail>()
                .Property(e => e.Paid)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_StatementDetail>()
                .Property(e => e.Weight)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_StatementDetail>()
                .Property(e => e.UnitPrice)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Fee_Workload>()
                .Property(e => e.ItemValue)
                .HasPrecision(18, 3);

            modelBuilder.Entity<Fee_Workload>()
                .Property(e => e.UnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Fee_Workload>()
                .Property(e => e.TotalPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AccountChange>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AccountChange>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AccountChange>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AccountChangeList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AccountCheck>()
                .Property(e => e.CurrentMoneyRMB)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Finance_AccountCheck>()
                .Property(e => e.CheckMoneyRMB)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Finance_AccountCheck>()
                .Property(e => e.ResultMoneyRMB)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Finance_AccountItem>()
                .Property(e => e.AccountBalance)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AccountVoucher>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AccountVoucherList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Adjustment>()
                .Property(e => e.AdjustMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Adjustment>()
                .Property(e => e.SettletMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Adjustment>()
                .Property(e => e.UnsettledMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Adjustment_Provider>()
                .Property(e => e.AdjustMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Adjustment_Provider>()
                .Property(e => e.SettletMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Adjustment_Provider>()
                .Property(e => e.UnsettledMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AssetDepreciation>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AssetDepreciationList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AssetFixed>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AssetFixed>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AssetFixed>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AssetFixedList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AssetSale>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AssetSale>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AssetSale>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_AssetSaleList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_BankAccount>()
                .Property(e => e.CurrentRMB)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Finance_BankAccount>()
                .Property(e => e.OriginalRMB)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Finance_BankBiz>()
                .Property(e => e.MoneyRMB)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Finance_BankFee>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_BankFee>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_BankFee>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_BankFeeList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Fee>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Fee>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Fee>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Fee>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Fee_Income>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Fee_Income>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Fee_Income>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Fee_Income>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Fee_Transfer>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_FeeList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Flow>()
                .Property(e => e.IncomeRMB)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Flow>()
                .Property(e => e.OutcomeRMB)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Flow>()
                .Property(e => e.BalanceRMB)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Finance_Pay_Purchase>()
                .Property(e => e.PayablesTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Pay_Purchase>()
                .Property(e => e.PaidTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Pay_Purchase>()
                .Property(e => e.FavourTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Pay_Purchase>()
                .Property(e => e.SettleTotal)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Finance_Pay_Purchase>()
                .Property(e => e.AdjustMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Finance_Pay_PurchaseList>()
                .Property(e => e.TotalSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Pay_PurchaseList>()
                .Property(e => e.FavourTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Pay_PurchaseList>()
                .Property(e => e.TotalUnSettle)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Finance_Pay_Return>()
                .Property(e => e.PayablesTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Pay_Return>()
                .Property(e => e.PaidTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Pay_Return>()
                .Property(e => e.FavourTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Pay_Return>()
                .Property(e => e.SettleTotal)
                .HasPrecision(19, 4);

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

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

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

            modelBuilder.Entity<Finance_Pay_ReturnList>()
                .Property(e => e.TotalSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Pay_ReturnList>()
                .Property(e => e.FavourTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Pay_ReturnList>()
                .Property(e => e.TotalUnSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PayableDecrease>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PayableDecreaseList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PayableIncrease>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PayableIncrease>()
                .HasMany(e => e.Finance_PayableIncreaseList)
                .WithRequired(e => e.Finance_PayableIncrease)
                .WillCascadeOnDelete(false);

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

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

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

            modelBuilder.Entity<Finance_Payout>()
                .Property(e => e.TotalSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Payout>()
                .Property(e => e.FavourTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Payout>()
                .Property(e => e.TotalUnSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Payout>()
                .HasMany(e => e.Finance_PayoutList)
                .WithOptional(e => e.Finance_Payout)
                .WillCascadeOnDelete();

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

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

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

            modelBuilder.Entity<Finance_PayoutList>()
                .Property(e => e.TotalSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PayoutList>()
                .Property(e => e.FavourTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PayoutList>()
                .Property(e => e.TotalUnSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrepaidAmortizement>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrepaidAmortizementList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrepaidOccurred>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrepaidOccurredList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Prepay>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Prepay>()
                .HasMany(e => e.Finance_PrepayList)
                .WithRequired(e => e.Finance_Prepay)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Finance_PrepayList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrepayToPayout>()
                .Property(e => e.PayableMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrepayToPayout>()
                .Property(e => e.PrepayMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrepayToPayout>()
                .Property(e => e.PayoutMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrepayToPayout>()
                .Property(e => e.SurplusMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrepayToPayoutList>()
                .Property(e => e.BillMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrepayToPayoutList>()
                .Property(e => e.SettleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrepayToPayoutList>()
                .Property(e => e.CurrentSettleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrepayToPayoutList>()
                .Property(e => e.UnSettleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Prereceive>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Prereceive>()
                .HasMany(e => e.Finance_PrereceiveList)
                .WithRequired(e => e.Finance_Prereceive)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Finance_PrereceiveList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrereceiveToReceive>()
                .Property(e => e.ReceivableMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrereceiveToReceive>()
                .Property(e => e.PrepayMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrereceiveToReceive>()
                .Property(e => e.PayoutMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrereceiveToReceive>()
                .Property(e => e.SurplusMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrereceiveToReceiveList>()
                .Property(e => e.BillMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrereceiveToReceiveList>()
                .Property(e => e.SettleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrereceiveToReceiveList>()
                .Property(e => e.CurrentSettleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_PrereceiveToReceiveList>()
                .Property(e => e.UnSettleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_ReceivableDecrease>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_ReceivableDecreaseList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_ReceivableIncrease>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_ReceivableIncreaseList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

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

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

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

            modelBuilder.Entity<Finance_Receive>()
                .Property(e => e.TotalSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Receive>()
                .Property(e => e.FavourTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Receive>()
                .Property(e => e.TotalUnSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Receive>()
                .Property(e => e.AdjustMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_Receive>()
                .HasMany(e => e.Finance_ReceiveList)
                .WithOptional(e => e.Finance_Receive)
                .WillCascadeOnDelete();

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

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

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

            modelBuilder.Entity<Finance_ReceiveList>()
                .Property(e => e.TotalSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_ReceiveList>()
                .Property(e => e.FavourTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_ReceiveList>()
                .Property(e => e.TotalUnSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_ReceiveOther>()
                .Property(e => e.TotalAmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_ReceiveOther>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_ReceiveOther>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Finance_ReceiveOtherList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_Product>()
                .HasMany(e => e.GuanYi_ProductSKU)
                .WithRequired(e => e.GuanYi_Product)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<GuanYi_SaleOrder>()
                .Property(e => e.amount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_SaleOrder>()
                .Property(e => e.payment_amount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_SaleOrder>()
                .Property(e => e.post_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_SaleOrder>()
                .Property(e => e.discount_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_SaleOrder>()
                .Property(e => e.payment)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_SaleOrder>()
                .Property(e => e.post_cost)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_SaleOrder>()
                .Property(e => e.invoice_amount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_SaleOrderList>()
                .Property(e => e.price)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_SaleOrderList>()
                .Property(e => e.amount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_SaleOrderList>()
                .Property(e => e.discount_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_SaleOrderList>()
                .Property(e => e.amount_after)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_SaleOrderList>()
                .Property(e => e.post_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<GuanYi_StoreInfo>()
                .Property(e => e.AppUrl)
                .IsUnicode(false);

            modelBuilder.Entity<IDX_PickToLight>()
                .Property(e => e.FMLocation)
                .IsUnicode(false);

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

            modelBuilder.Entity<IDX_PickToLight>()
                .Property(e => e.TaskProcess)
                .IsFixedLength();

            modelBuilder.Entity<JingDong_StoreInfo>()
                .Property(e => e.AppKey)
                .IsUnicode(false);

            modelBuilder.Entity<JingDong_StoreInfo>()
                .Property(e => e.AppSecret)
                .IsUnicode(false);

            modelBuilder.Entity<JingDong_StoreInfo>()
                .Property(e => e.AccessToken)
                .IsUnicode(false);

            modelBuilder.Entity<JingDong_StoreInfo>()
                .Property(e => e.MerchantAccount)
                .IsUnicode(false);

            modelBuilder.Entity<JingDong_StoreInfo>()
                .Property(e => e.UID)
                .IsUnicode(false);

            modelBuilder.Entity<JingDong_StoreInfo>()
                .Property(e => e.User_Nick)
                .IsUnicode(false);

            modelBuilder.Entity<JingDong_StoreInfo>()
                .Property(e => e.Token_Type)
                .IsUnicode(false);

            //modelBuilder.Entity<lackOrderList>()
            //    .HasOptional(e => e.lackOrderList1)
            //    .WithRequired(e => e.lackOrderList2);

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

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

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

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

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

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

            modelBuilder.Entity<Magento_OrderShipmentCreate_Item>()
                .Property(e => e.qty)
                .HasPrecision(18, 0);

            modelBuilder.Entity<Magento_SKUCustomOptionValue_Relation>()
                .Property(e => e.price)
                .HasPrecision(19, 4);

            modelBuilder.Entity<MoYun_Sale_Order_Tran>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 3);

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

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

            modelBuilder.Entity<Msg_BaseInfo>()
                .HasMany(e => e.Msg_UserContent)
                .WithOptional(e => e.Msg_BaseInfo)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Msg_BaseInfo>()
                .HasMany(e => e.Msg_UserRelation)
                .WithOptional(e => e.Msg_BaseInfo)
                .WillCascadeOnDelete();

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

            modelBuilder.Entity<OA_RegUserInfo>()
                .Property(e => e.StoreUrl)
                .IsUnicode(false);

            modelBuilder.Entity<OA_RegUserInfo>()
                .Property(e => e.SalerRemark)
                .IsUnicode(false);

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

            modelBuilder.Entity<Purchase_ArrivalProcessList>()
                .Property(e => e.ClearanceQauntity)
                .HasPrecision(14, 4);

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<Purchase_Enter>()
                .Property(e => e.TotalFavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Enter>()
                .Property(e => e.TotalFactMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Purchase_Enter>()
                .Property(e => e.SettleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Enter>()
                .Property(e => e.UnSettleMoney)
                .HasPrecision(19, 4);

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

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

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

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

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

            modelBuilder.Entity<Purchase_EnterList>()
                .Property(e => e.ShelveQuantity)
                .HasPrecision(14, 4);

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

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

            modelBuilder.Entity<Purchase_EnterList>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_EnterList>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

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

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

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

            modelBuilder.Entity<Purchase_EnterList>()
                .Property(e => e.UnfinishedQuantity)
                .HasPrecision(14, 4);

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

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

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

            modelBuilder.Entity<Purchase_EnterList>()
                .Property(e => e.UnitPackage)
                .HasPrecision(18, 5);

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

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

            modelBuilder.Entity<Purchase_Exchange>()
                .Property(e => e.OuterTotalQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_Exchange>()
                .Property(e => e.OuterTotalMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Exchange>()
                .Property(e => e.EnterTotalQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_Exchange>()
                .Property(e => e.EnterTotalMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Exchange>()
                .Property(e => e.DifferenceMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Exchange>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Exchange>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_Exchange>()
                .Property(e => e.PayMoney)
                .HasPrecision(19, 4);

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<Purchase_ExchangeOuterList>()
                .Property(e => e.RateMoney)
                .HasPrecision(19, 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_Order_Paid>()
                .Property(e => e.PaidMoney)
                .HasPrecision(19, 4);

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

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

            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<Purchase_OrderRush>()
                .Property(e => e.PayedMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderRush>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderRush>()
                .Property(e => e.LastBalanceMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderRush>()
                .Property(e => e.UseableMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderRush>()
                .Property(e => e.CurrentBalanceMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderRush>()
                .Property(e => e.TotalRushed)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderRush>()
                .Property(e => e.TotalUnRushed)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderRush>()
                .HasMany(e => e.Purchase_OrderRushList)
                .WithOptional(e => e.Purchase_OrderRush)
                .WillCascadeOnDelete();

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

            modelBuilder.Entity<Purchase_OrderRushList>()
                .Property(e => e.PayableMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderRushList>()
                .Property(e => e.GatherMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Purchase_OrderRushList>()
                .Property(e => e.UnGatherMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Purchase_QualityCheckList>()
                .Property(e => e.CheckQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_QualityCheckList>()
                .Property(e => e.DefectiveQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Purchase_QualityCheckList>()
                .Property(e => e.QualifiedRate)
                .HasPrecision(18, 4);

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

            modelBuilder.Entity<Purchase_Quotation>()
                .HasMany(e => e.Purchase_QuotationList)
                .WithRequired(e => e.Purchase_Quotation)
                .WillCascadeOnDelete(false);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<Purchase_Return>()
                .Property(e => e.ReturnMoney)
                .HasPrecision(19, 4);

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

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

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

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

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

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

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

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

            modelBuilder.Entity<Purchase_ReturnList>()
                .Property(e => e.OutQuantity)
                .HasPrecision(14, 4);

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

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

            modelBuilder.Entity<Purchase_ReturnList>()
                .Property(e => e.TotalWeight)
                .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<Purchase_ShelveListDetail>()
                .Property(e => e.ProductCode)
                .IsUnicode(false);

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

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

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

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

            modelBuilder.Entity<Qimen_DeliveryOrder_Batch_Answer>()
                .Property(e => e.PushStatus)
                .IsFixedLength();

            modelBuilder.Entity<Qimen_Inventory_Report>()
                .Property(e => e.PushStatus)
                .IsFixedLength();

            modelBuilder.Entity<Qimen_Itemlack_Report>()
                .Property(e => e.PushStatus)
                .IsFixedLength();

            modelBuilder.Entity<Qimen_OrderException_Report>()
                .Property(e => e.PushStatus)
                .IsFixedLength();

            modelBuilder.Entity<Qimen_OrderProcess_Report>()
                .Property(e => e.PushStatus)
                .IsFixedLength();

            modelBuilder.Entity<Qimen_Sn_Report>()
                .Property(e => e.PushStatus)
                .IsFixedLength();

            modelBuilder.Entity<Qimen_StockChange_Report>()
                .Property(e => e.PushStatus)
                .IsFixedLength();

            modelBuilder.Entity<Qimen_Wavenum_Report>()
                .Property(e => e.PushStatus)
                .IsFixedLength();

            modelBuilder.Entity<region_directory>()
                .Property(e => e.name)
                .IsUnicode(false);

            modelBuilder.Entity<region_directory>()
                .Property(e => e.name_CN)
                .IsUnicode(false);

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

            modelBuilder.Entity<Require_Allocation>()
                .Property(e => e.ProductMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Require_Allocation>()
                .HasMany(e => e.Require_AllocationList)
                .WithOptional(e => e.Require_Allocation)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Require_AllocationList>()
                .Property(e => e.GoodsQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Require_AllocationList>()
                .Property(e => e.ProductPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Require_AllocationList>()
                .Property(e => e.ProductTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Require_AllocationList>()
                .Property(e => e.SortingQuantity)
                .HasPrecision(14, 4);

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

            modelBuilder.Entity<Require_AllocationList>()
                .Property(e => e.ProfitQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Require_AllocationList>()
                .Property(e => e.LossQuantity)
                .HasPrecision(14, 4);

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

            modelBuilder.Entity<Require_Goods>()
                .Property(e => e.ProductMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Require_Goods>()
                .HasMany(e => e.Require_GoodsList)
                .WithOptional(e => e.Require_Goods)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Require_GoodsList>()
                .Property(e => e.GoodsQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Require_GoodsList>()
                .Property(e => e.ProductPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Require_GoodsList>()
                .Property(e => e.ProductTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Require_Voucher>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(12, 4);

            modelBuilder.Entity<Require_Voucher>()
                .Property(e => e.SalePrice)
                .HasPrecision(12, 4);

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

            modelBuilder.Entity<Rule_Bundle>()
                .Property(e => e.BundleSalePrice)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Rule_Coupon>()
                .Property(e => e.MeetAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Rule_Coupon>()
                .Property(e => e.DeductibleAmount)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Rule_FlashSale>()
                .Property(e => e.FlashSalePrice)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Rule_Gift>()
                .HasMany(e => e.Rule_GiftImage)
                .WithRequired(e => e.Rule_Gift)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Rule_GroupBuy>()
                .Property(e => e.LiquidatedDamages)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Rule_GroupBuy>()
                .Property(e => e.MemberPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Rule_GroupBuy>()
                .Property(e => e.GroupBuyPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Rule_MixedBatch>()
                .Property(e => e.DiscountedValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Rule_MixedBatch>()
                .Property(e => e.SaleAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Rule_MixedBatch>()
                .Property(e => e.StandByAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Rule_OrderPromotion>()
                .Property(e => e.MeetAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Rule_OrderPromotion>()
                .Property(e => e.DiscountedValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Rule_OrderPromotion>()
                .Property(e => e.StandByAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Rule_ProductPromotion>()
                .Property(e => e.DiscountedValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Rule_ProductPromotion>()
                .Property(e => e.SaleAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Rule_ProductPromotion>()
                .Property(e => e.StandByAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Rule_ProductPromotion>()
                .HasMany(e => e.Rule_ProductPromotionGift)
                .WithRequired(e => e.Rule_ProductPromotion)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Rule_ProductPromotion>()
                .HasMany(e => e.Rule_ProductPromotionList)
                .WithRequired(e => e.Rule_ProductPromotion)
                .WillCascadeOnDelete(false);

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

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

            modelBuilder.Entity<Rule_WholeSale>()
                .Property(e => e.DiscountedValue)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Sale_Exchange>()
                .Property(e => e.EnterTotalQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Exchange>()
                .Property(e => e.EnterTotalMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Exchange>()
                .Property(e => e.OuterTotalQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Exchange>()
                .Property(e => e.OuterTotalMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Exchange>()
                .Property(e => e.DifferenceMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Exchange>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Exchange>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Exchange>()
                .Property(e => e.ReceiveMoney)
                .HasPrecision(19, 4);

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

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

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

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

            modelBuilder.Entity<Sale_ExchangeEnterList>()
                .Property(e => e.SaleMoney)
                .HasPrecision(19, 4);

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

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

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

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

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

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

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

            modelBuilder.Entity<Sale_ExchangeOuterList>()
                .Property(e => e.SaleMoney)
                .HasPrecision(19, 4);

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

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

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

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

            modelBuilder.Entity<Sale_LoadBill>()
                .HasMany(e => e.Sale_LoadBillList)
                .WithOptional(e => e.Sale_LoadBill)
                .WillCascadeOnDelete();

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

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

            modelBuilder.Entity<Sale_LoadBill_Trajectory>()
                .Property(e => e.Longitude)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Sale_LoadBill_Trajectory>()
                .Property(e => e.Latitude)
                .HasPrecision(18, 6);

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

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

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

            modelBuilder.Entity<Sale_LoadBillList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Sale_LoadBillList>()
                .Property(e => e.GrandTotal)
                .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_Order>()
                .HasMany(e => e.Sale_Order_StatusHistory)
                .WithOptional(e => e.Sale_Order)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Sale_Order_Paid>()
                .Property(e => e.PaidMoney)
                .HasPrecision(19, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<Sale_Order_Temp>()
                .Property(e => e.RowPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order_Temp>()
                .Property(e => e.TempSalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Order_Temp>()
                .Property(e => e.AttachAmount)
                .HasPrecision(19, 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<Sale_OrderMatching>()
                .Property(e => e.SpanTime)
                .IsUnicode(false);

            modelBuilder.Entity<Sale_OrderMatching>()
                .Property(e => e.TotalQuanity)
                .HasPrecision(14, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<Sale_OrderPlan>()
                .Property(e => e.PredictMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Sale_OrderPlan>()
                .Property(e => e.CheckoutQuantity)
                .HasPrecision(14, 4);

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

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

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

            modelBuilder.Entity<Sale_OrderPlanDetail>()
                .Property(e => e.SaleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_OrderPlanDetail>()
                .Property(e => e.CompleteQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_OrderPlanDetail>()
                .Property(e => e.SurplusQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_OrderPlanDetail>()
                .Property(e => e.LastQuantity)
                .HasPrecision(14, 4);

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

            modelBuilder.Entity<Sale_OrderPlanDetail>()
                .Property(e => e.totalWeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Sale_OrderPlanDetail>()
                .Property(e => e.OriginPlace)
                .IsFixedLength();

            modelBuilder.Entity<Sale_OrderPrint>()
                .Property(e => e.FreezeQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_OrderPrint>()
                .Property(e => e.TotalQuanity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_OrderPrint>()
                .Property(e => e.PickQuantity)
                .HasPrecision(14, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<Sale_Outer>()
                .Property(e => e.TotalRateAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Outer>()
                .Property(e => e.SettleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Outer>()
                .Property(e => e.UnSettleMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Sale_Outer>()
                .Property(e => e.TotalPackage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Outer>()
                .Property(e => e.TotalVolume)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Sale_Outer>()
                .Property(e => e.checkoutQuantity)
                .HasPrecision(14, 4);

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

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<Sale_OuterList>()
                .Property(e => e.RateAmount)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Sale_OuterList>()
                .Property(e => e.CompleteQuantity)
                .HasPrecision(14, 4);

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

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

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

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

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

            modelBuilder.Entity<Sale_Retail>()
                .HasMany(e => e.Sale_RetailList)
                .WithRequired(e => e.Sale_Retail)
                .WillCascadeOnDelete(false);

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<Sale_Return>()
                .Property(e => e.ReturnMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Return>()
                .Property(e => e.RefundMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Return>()
                .Property(e => e.UnrefundMoney)
                .HasPrecision(19, 4);

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

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

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

            modelBuilder.Entity<Sale_Return>()
                .Property(e => e.Weight)
                .HasPrecision(18, 6);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<Sale_Send>()
                .Property(e => e.SendCode)
                .IsUnicode(false);

            modelBuilder.Entity<Sale_Send>()
                .Property(e => e.AgentTotalMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Sale_Send>()
                .Property(e => e.GatherMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Send>()
                .Property(e => e.UnGatherMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Sale_Send>()
                .Property(e => e.ClientShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Send>()
                .Property(e => e.TotalShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_Send>()
                .Property(e => e.GoodsValue)
                .HasPrecision(19, 4);

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

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

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

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

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

            modelBuilder.Entity<Sale_SendList>()
                .Property(e => e.GatherMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_SendList>()
                .Property(e => e.UnGatherMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Sale_SendList>()
                .Property(e => e.ClientShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_SendList>()
                .Property(e => e.TotalShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_SendList>()
                .Property(e => e.AgentTotalMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_SendList>()
                .Property(e => e.Solidity)
                .HasPrecision(18, 4);

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

            modelBuilder.Entity<Sale_SendList>()
                .Property(e => e.ServiceValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_SendList>()
                .Property(e => e.InsuranceAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Sale_SendList>()
                .Property(e => e.InsuranceFee)
                .HasPrecision(19, 4);

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

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

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

            modelBuilder.Entity<Sale_TransfterCheckList>()
                .Property(e => e.FreightMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Sale_TransfterList>()
                .Property(e => e.FreightMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<SapSendFailRecodInfo>()
                .Property(e => e.Quantity)
                .HasPrecision(12, 8);

            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<Stat_StorageDay>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Stat_StorageDay>()
                .Property(e => e.ScanInQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Stat_StorageDay>()
                .Property(e => e.ScanShelveQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Stat_StorageDay>()
                .Property(e => e.OtherInQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Stat_StorageDay>()
                .Property(e => e.BorrowInQuantity)
                .HasPrecision(14, 4);

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

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

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

            modelBuilder.Entity<Storage_Adjust>()
                .Property(e => e.TotalProductStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_Adjust>()
                .Property(e => e.TotalPurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_Adjust>()
                .Property(e => e.TotalCheckQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_Adjust>()
                .Property(e => e.TotalProfitQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_Adjust>()
                .Property(e => e.TotalProfitMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_Adjust>()
                .Property(e => e.TotalLossQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_Adjust>()
                .Property(e => e.TotalLossMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_Adjust>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

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

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

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

            modelBuilder.Entity<Storage_AdjustList>()
                .Property(e => e.CheckQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_AdjustList>()
                .Property(e => e.ProfitQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_AdjustList>()
                .Property(e => e.ProfitMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_AdjustList>()
                .Property(e => e.LossQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_AdjustList>()
                .Property(e => e.LossMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Storage_AdjustList>()
                .Property(e => e.PlaceholderStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_AdjustList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_AdjustList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 6);

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

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

            modelBuilder.Entity<Storage_AllocateApply>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

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

            modelBuilder.Entity<Storage_AllocateApply>()
                .HasMany(e => e.Storage_AllocateEnter)
                .WithRequired(e => e.Storage_AllocateApply)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Storage_AllocateApply>()
                .HasMany(e => e.Storage_AllocateApplyList)
                .WithOptional(e => e.Storage_AllocateApply)
                .WillCascadeOnDelete();

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

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

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

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

            modelBuilder.Entity<Storage_AllocateApplyList>()
                .Property(e => e.ValidQuantity)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Storage_AllocateApplyList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_AllocateApplyList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 6);

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

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

            modelBuilder.Entity<Storage_AllocateEnter>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

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

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

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

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

            modelBuilder.Entity<Storage_AllocateEnterList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_AllocateEnterList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_Assemble>()
                .Property(e => e.TotalOuterQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_Assemble>()
                .Property(e => e.TotalOuterMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Storage_Assemble>()
                .Property(e => e.TotalEnterMoney)
                .HasPrecision(19, 4);

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

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

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

            modelBuilder.Entity<Storage_AssembleOuterList>()
                .Property(e => e.OuterQuantity)
                .HasPrecision(14, 4);

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

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

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

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

            modelBuilder.Entity<Storage_BorrowEnter>()
                .Property(e => e.TotalEnterMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Storage_BorrowEnterList>()
                .Property(e => e.EnterMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Storage_BorrowEnterReturn>()
                .Property(e => e.TotalEnterMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_BorrowEnterReturn>()
                .Property(e => e.TotalReturnQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_BorrowEnterReturn>()
                .Property(e => e.TotalReturnMoney)
                .HasPrecision(19, 4);

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

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

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

            modelBuilder.Entity<Storage_BorrowEnterReturnList>()
                .Property(e => e.EnterMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_BorrowEnterReturnList>()
                .Property(e => e.ReturnMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Storage_BorrowOuter>()
                .Property(e => e.TotalOuterQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_BorrowOuter>()
                .Property(e => e.TotalOuterMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_BorrowOuterList>()
                .Property(e => e.OuterQuantity)
                .HasPrecision(14, 4);

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

            modelBuilder.Entity<Storage_BorrowOuterList>()
                .Property(e => e.OuterMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Storage_BorrowOuterReturn>()
                .Property(e => e.TotalOuterQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_BorrowOuterReturn>()
                .Property(e => e.TotalOuterMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_BorrowOuterReturn>()
                .Property(e => e.TotalReturnQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_BorrowOuterReturn>()
                .Property(e => e.TotalReturnMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_BorrowOuterReturnList>()
                .Property(e => e.OuterQuantity)
                .HasPrecision(14, 4);

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

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

            modelBuilder.Entity<Storage_BorrowOuterReturnList>()
                .Property(e => e.OuterMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_BorrowOuterReturnList>()
                .Property(e => e.ReturnMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_Check>()
                .Property(e => e.TotalPurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_Check>()
                .Property(e => e.TotalCheckQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_Check>()
                .Property(e => e.TotalProfitQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_Check>()
                .Property(e => e.TotalProfitMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_Check>()
                .Property(e => e.TotalLossQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_Check>()
                .Property(e => e.TotalLossMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_Check>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

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

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

            modelBuilder.Entity<Storage_CheckList>()
                .Property(e => e.CheckQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_CheckList>()
                .Property(e => e.ProfitQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_CheckList>()
                .Property(e => e.ProfitMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_CheckList>()
                .Property(e => e.LossQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_CheckList>()
                .Property(e => e.LossMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_CheckList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_CheckList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

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

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

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

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

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

            modelBuilder.Entity<Storage_ConsignorTransferList>()
                .Property(e => e.TransferQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_ConsignorTransferList>()
                .Property(e => e.SubTotalMoney)
                .HasPrecision(19, 4);

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

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

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

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

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

            modelBuilder.Entity<Storage_Enter>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

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

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

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

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

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

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

            modelBuilder.Entity<Storage_EnterList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_EnterList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_Loss>()
                .Property(e => e.TotalPurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_Loss>()
                .Property(e => e.TotalLossMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Storage_LossList>()
                .Property(e => e.LossMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Storage_Outer>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_Outer>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Storage_Outer>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

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

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

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

            modelBuilder.Entity<Storage_OuterList>()
                .Property(e => e.SaleMoney)
                .HasPrecision(19, 4);

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

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

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

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

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

            modelBuilder.Entity<Storage_OuterList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_OuterList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

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

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

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

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

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

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

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

            modelBuilder.Entity<Storage_PositionTransferList>()
                .Property(e => e.TransferQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_PositionTransferList>()
                .Property(e => e.SubTotalMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Storage_Profit>()
                .Property(e => e.TotalPurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_Profit>()
                .Property(e => e.TotalProfitMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Storage_ProfitList>()
                .Property(e => e.ProfitMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_ProfitLoss>()
                .Property(e => e.TotalPurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_ProfitLoss>()
                .Property(e => e.TotalCheckQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_ProfitLoss>()
                .Property(e => e.TotalProfitQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<Storage_ProfitLoss>()
                .Property(e => e.TotalProfitMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_ProfitLoss>()
                .Property(e => e.TotalLossMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_ProfitLoss>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

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

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

            modelBuilder.Entity<Storage_ProfitLossList>()
                .Property(e => e.ProfitMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_ProfitLossList>()
                .Property(e => e.LossMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_ProfitLossList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_ProfitLossList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_PurchasePriceAdjust>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

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

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

            modelBuilder.Entity<Storage_PurchasePriceAdjustList>()
                .Property(e => e.AdjustPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_PurchasePriceAdjustList>()
                .Property(e => e.DiffPrice)
                .HasPrecision(19, 4);

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

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

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

            modelBuilder.Entity<Storage_PurchasePriceAdjustList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_PurchasePriceAdjustList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 6);

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

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

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

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

            modelBuilder.Entity<Storage_ReplenishmentList>()
                .Property(e => e.TransferQuantity)
                .HasPrecision(14, 4);

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

            modelBuilder.Entity<Storage_ReplenishmentList>()
                .Property(e => e.SubTotalMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<Storage_ReplenishmentList>()
                .Property(e => e.OutQuantity)
                .HasPrecision(14, 4);

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

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

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

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

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

            modelBuilder.Entity<Storage_ReplenishmentScanList>()
                .Property(e => e.SubTotalMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Storage_ReplenishmentScanList>()
                .Property(e => e.TransferWeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Storage_ValidAdjust>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_ValidAdjustList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<Storage_ValidAdjustList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 6);

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

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

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

            modelBuilder.Entity<Sys_Dept>()
                .Property(e => e.DeleteBy)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_DropDown>()
                .Property(e => e.Script)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ExportColumnInfo>()
                .Property(e => e.ColumnName)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ExportColumnInfo>()
                .Property(e => e.CnName)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ExportColumnInfo>()
                .Property(e => e.ColExpression)
                .IsUnicode(false);

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

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

            modelBuilder.Entity<Sys_ExportInfo>()
                .Property(e => e.TableName)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ExportInfo>()
                .Property(e => e.TableNameCn)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ExportInfo>()
                .Property(e => e.ExportType)
                .IsUnicode(false);

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

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

            modelBuilder.Entity<Sys_ExportVueData>()
                .Property(e => e.VueData)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ImportColumnInfo>()
                .Property(e => e.ColumnType)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ImportColumnInfo>()
                .Property(e => e.ColumnName)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ImportColumnInfo>()
                .Property(e => e.CnName)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ImportColumnInfo>()
                .Property(e => e.Validate)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ImportColumnInfo>()
                .Property(e => e.ValExpression)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ImportColumnInfo>()
                .Property(e => e.ValDescription)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ImportColumnInfo>()
                .Property(e => e.Express)
                .IsUnicode(false);

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

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

            modelBuilder.Entity<Sys_ImportInfo>()
                .Property(e => e.TableName)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ImportInfo>()
                .Property(e => e.TableNameCn)
                .IsUnicode(false);

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

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

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

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

            modelBuilder.Entity<Sys_Log>()
                .Property(e => e.DeleteBy)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_MenuApp>()
                .Property(e => e.VueData)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_MvcTableInfo>()
                .Property(e => e.LogicDataKey)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_MvcTableInfo>()
                .Property(e => e.FolderName)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_MvcTableInfo>()
                .Property(e => e.Namespace)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_MvcTableInfo>()
                .Property(e => e.DeleteBy)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_MvcTableInfo>()
                .Property(e => e.FromColumnNo)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_MvcTableInfo>()
                .Property(e => e.VueData)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_MvcTableInfo>()
                .Property(e => e.UserJson)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_MvcTableInfo>()
                .HasMany(e => e.Sys_MvcTableColumn)
                .WithOptional(e => e.Sys_MvcTableInfo)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Sys_MvcUserData>()
                .Property(e => e.userJson)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_MvcVueData>()
                .Property(e => e.VueData)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_ParamType>()
                .HasMany(e => e.Sys_ParamValue)
                .WithOptional(e => e.Sys_ParamType)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Sys_Role>()
                .HasMany(e => e.Sys_RoleAuthDataAll)
                .WithOptional(e => e.Sys_Role)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Sys_Role>()
                .HasMany(e => e.Sys_Role_IsDataAuth)
                .WithRequired(e => e.Sys_Role)
                .HasForeignKey(e => e.Roles_Id);

            modelBuilder.Entity<Sys_Role>()
                .HasMany(e => e.Sys_RoleAuth)
                .WithOptional(e => e.Sys_Role)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Sys_Role>()
                .HasMany(e => e.Sys_RoleAuthData)
                .WithOptional(e => e.Sys_Role)
                .WillCascadeOnDelete();

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

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

            modelBuilder.Entity<Sys_Site>()
                .Property(e => e.DeleteBy)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_StatInfo>()
                .Property(e => e.Namespace)
                .IsUnicode(false);

            modelBuilder.Entity<Sys_StatInfo>()
                .Property(e => e.FolderName)
                .IsUnicode(false);

            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<Sys_User_Log>()
                .Property(e => e.Creator)
                .IsUnicode(false);

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

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

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

            modelBuilder.Entity<Sys_UserConfig>()
                .Property(e => e.DeleteBy)
                .IsUnicode(false);

            modelBuilder.Entity<Taobao_Product_Relation>()
                .Property(e => e.auction_point)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Taobao_Product_Relation>()
                .Property(e => e.price)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_Product_Relation>()
                .Property(e => e.post_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_Product_Relation>()
                .Property(e => e.express_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_Product_Relation>()
                .Property(e => e.ems_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_Product_Variation>()
                .Property(e => e.SkuPrice)
                .HasPrecision(19, 4);

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

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

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

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

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

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

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.payment)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.post_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.available_confirm_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.received_payment)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.price)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.seller_cod_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.discount_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.total_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.yfx_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.credit_card_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.step_paid_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.buyer_cod_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.express_agency_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.adjust_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.cod_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .Property(e => e.commission_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrder>()
                .HasMany(e => e.Taobao_SaleOrderList)
                .WithOptional(e => e.Taobao_SaleOrder)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Taobao_SaleOrderList>()
                .Property(e => e.price)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrderList>()
                .Property(e => e.total_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrderList>()
                .Property(e => e.payment)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrderList>()
                .Property(e => e.discount_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrderList>()
                .Property(e => e.adjust_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrderList>()
                .Property(e => e.divide_order_fee)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Taobao_SaleOrderList>()
                .Property(e => e.part_mjz_discount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Template_SendBill>()
                .HasMany(e => e.Template_SendBillList)
                .WithOptional(e => e.Template_SendBill)
                .WillCascadeOnDelete();

            modelBuilder.Entity<TMS_Abnormal>()
                .HasMany(e => e.TMS_Abnormal_Address)
                .WithOptional(e => e.TMS_Abnormal)
                .WillCascadeOnDelete();

            modelBuilder.Entity<TMS_BalanceList>()
                .Property(e => e.BaseReceiveTotal)
                .HasPrecision(18, 0);

            modelBuilder.Entity<TMS_Claim>()
                .Property(e => e.QuantityClaim)
                .HasPrecision(14, 4);

            modelBuilder.Entity<TMS_Claim>()
                .Property(e => e.GrandTotal)
                .HasPrecision(18, 0);

            modelBuilder.Entity<TMS_Claim>()
                .Property(e => e.ClaimAmount)
                .HasPrecision(18, 0);

            modelBuilder.Entity<TMS_Claim>()
                .HasMany(e => e.TMS_Claim_Acceptance)
                .WithRequired(e => e.TMS_Claim)
                .WillCascadeOnDelete(false);

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

            modelBuilder.Entity<TMS_Distribution>()
                .Property(e => e.TotalVolume)
                .HasPrecision(14, 4);

            modelBuilder.Entity<TMS_Distribution>()
                .Property(e => e.TotalNumber)
                .HasPrecision(14, 4);

            modelBuilder.Entity<TMS_Distribution>()
                .HasMany(e => e.TMS_DistributionDetail)
                .WithOptional(e => e.TMS_Distribution)
                .WillCascadeOnDelete();

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

            modelBuilder.Entity<TMS_DistributionDetail>()
                .Property(e => e.GrandTotal)
                .HasPrecision(18, 0);

            modelBuilder.Entity<TMS_DistributionDetail>()
                .Property(e => e.TotalVolume)
                .HasPrecision(14, 4);

            modelBuilder.Entity<TMS_DistributionDetail>()
                .Property(e => e.TotalFreight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<TMS_DistributionDetail>()
                .Property(e => e.TotalUnitPrice)
                .HasPrecision(18, 6);

            modelBuilder.Entity<TMS_DistributionDetail>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 0);

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

            modelBuilder.Entity<TMS_FeeItem>()
                .Property(e => e.UnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<TMS_FeeTemplate>()
                .Property(e => e.UnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<TMS_FeeTemplate>()
                .HasMany(e => e.TMS_FeeTemplateList)
                .WithOptional(e => e.TMS_FeeTemplate)
                .WillCascadeOnDelete();

            modelBuilder.Entity<TMS_FreightPrice>()
                .Property(e => e.FeeRate)
                .HasPrecision(14, 4);

            modelBuilder.Entity<TMS_OilCard>()
                .Property(e => e.AmountSurplus)
                .HasPrecision(19, 4);

            modelBuilder.Entity<TMS_OilCard>()
                .Property(e => e.AmountUse)
                .HasPrecision(19, 4);

            modelBuilder.Entity<TMS_OilConsume>()
                .Property(e => e.MoneyUseAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<TMS_OilRecharge>()
                .Property(e => e.RechargeAmount)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<TMS_Pickup>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 12);

            modelBuilder.Entity<TMS_Pickup>()
                .Property(e => e.TotalVolume)
                .HasPrecision(18, 12);

            modelBuilder.Entity<TMS_Pickup>()
                .Property(e => e.Volume)
                .HasPrecision(18, 12);

            modelBuilder.Entity<TMS_PickupDetail>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 12);

            modelBuilder.Entity<TMS_Port>()
                .Property(e => e.RuleSingleValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<TMS_Port>()
                .Property(e => e.IsRuleSingleWeight)
                .HasPrecision(18, 0);

            modelBuilder.Entity<TMS_PositionDetails>()
                .Property(e => e.Longitude)
                .HasPrecision(18, 6);

            modelBuilder.Entity<TMS_PositionDetails>()
                .Property(e => e.Latitude)
                .HasPrecision(18, 6);

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

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

            modelBuilder.Entity<TMS_ProductInfo_Port>()
                .Property(e => e.DeclareQuantityOrder)
                .HasPrecision(14, 4);

            modelBuilder.Entity<TMS_ProductInfo_Port>()
                .Property(e => e.DeclarePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<TMS_ProductInfo_Port>()
                .Property(e => e.StatutoryQty1)
                .HasPrecision(18, 4);

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

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<TMS_QuotationList>()
                .Property(e => e.InQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<TMS_Subsidy>()
                .Property(e => e.SubsidyReward)
                .HasPrecision(18, 0);

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

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

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

            modelBuilder.Entity<TMS_TrackReplay>()
                .Property(e => e.StartLongitude)
                .HasPrecision(18, 6);

            modelBuilder.Entity<TMS_TrackReplay>()
                .Property(e => e.StartLatitude)
                .HasPrecision(18, 6);

            modelBuilder.Entity<TMS_TrackReplay>()
                .Property(e => e.EndLongitude)
                .HasPrecision(18, 6);

            modelBuilder.Entity<TMS_TrackReplay>()
                .Property(e => e.EndLatitude)
                .HasPrecision(18, 6);

            modelBuilder.Entity<TMS_Transport>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 0);

            modelBuilder.Entity<TMS_Transport>()
                .HasMany(e => e.TMS_TransportDetail)
                .WithOptional(e => e.TMS_Transport)
                .WillCascadeOnDelete();

            modelBuilder.Entity<TMS_TransportDetail>()
                .Property(e => e.OutStation)
                .IsFixedLength();

            modelBuilder.Entity<TMS_TransportDetail>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 12);

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

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

            modelBuilder.Entity<TMS_WayBill>()
                .Property(e => e.GrandTotal)
                .HasPrecision(18, 0);

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

            modelBuilder.Entity<TMS_WayBill>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 9);

            modelBuilder.Entity<TMS_WayBill>()
                .Property(e => e.TotalVolume)
                .HasPrecision(14, 4);

            modelBuilder.Entity<TMS_WayBill>()
                .Property(e => e.TotalFreight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<TMS_WayBill>()
                .Property(e => e.TotalUnitPrice)
                .HasPrecision(18, 6);

            modelBuilder.Entity<TMS_WayBill>()
                .Property(e => e.Value)
                .HasPrecision(18, 6);

            modelBuilder.Entity<TMS_WayBill>()
                .HasMany(e => e.TMS_WayBillAbnormal)
                .WithOptional(e => e.TMS_WayBill)
                .WillCascadeOnDelete();

            modelBuilder.Entity<TMS_WayBill>()
                .HasMany(e => e.TMS_WayBillHistory)
                .WithRequired(e => e.TMS_WayBill)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<TMS_WayBillAbnormal>()
                .Property(e => e.AbnormalRemark)
                .IsFixedLength();

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

            modelBuilder.Entity<TMS_WayBillList>()
                .Property(e => e.SmallUnit)
                .IsFixedLength();

            modelBuilder.Entity<TMS_WayBillList>()
                .Property(e => e.SalePrice)
                .HasPrecision(18, 0);

            modelBuilder.Entity<TMS_WayBillList>()
                .Property(e => e.RowTotal)
                .HasPrecision(18, 0);

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

            modelBuilder.Entity<TMS_WayBillList>()
                .Property(e => e.GrossWeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<TMS_WayBillList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 14);

            modelBuilder.Entity<TMS_WayBillList>()
                .Property(e => e.LargUnits)
                .HasPrecision(14, 4);

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

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

            modelBuilder.Entity<TMS_WeiXin_WayBill>()
                .Property(e => e.grossWeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<TMS_WeiXin_WayBillList>()
                .Property(e => e.salePrice)
                .HasPrecision(18, 4);

            modelBuilder.Entity<TMS_WeiXin_WayBillList>()
                .Property(e => e.rowTotal)
                .HasPrecision(18, 4);

            modelBuilder.Entity<TMS_WeiXin_WayBillList>()
                .Property(e => e.weight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<TMS_WeiXin_WayBillList>()
                .Property(e => e.grossWeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Wdgj_Logistics>()
                .Property(e => e.Name)
                .IsUnicode(false);

            modelBuilder.Entity<Wdgj_Logistics>()
                .Property(e => e.LinkMan)
                .IsUnicode(false);

            modelBuilder.Entity<Wdgj_Logistics>()
                .Property(e => e.Tel)
                .IsUnicode(false);

            modelBuilder.Entity<Wdgj_Logistics>()
                .Property(e => e.BillStyle)
                .IsUnicode(false);

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

            modelBuilder.Entity<Wdgj_Logistics>()
                .Property(e => e.WebSite)
                .IsUnicode(false);

            modelBuilder.Entity<Wdgj_Logistics>()
                .Property(e => e.Balance)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_Logistics>()
                .Property(e => e.WeightUnit)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_Logistics>()
                .Property(e => e.WeightRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_Product>()
                .Property(e => e.Price_Cost)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_Product>()
                .Property(e => e.Price_Detail)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_Product>()
                .Property(e => e.Price_Wholesale)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_Product>()
                .Property(e => e.Price_Member)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_Product>()
                .Property(e => e.Price1)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_Product>()
                .Property(e => e.Price2)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_Product>()
                .Property(e => e.Price3)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_Product>()
                .Property(e => e.FixCostPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_Product>()
                .Property(e => e.Price_Bottom)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Wdgj_Product>()
                .HasMany(e => e.Wdgj_ProductSKU)
                .WithRequired(e => e.Wdgj_Product)
                .WillCascadeOnDelete(false);

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

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

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.otherCost)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.GoodsTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.PostageTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.TaxValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.CouponValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.FavourableTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.AllTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.RcvTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.GoodsCost)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.PackageCost)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.TotalProfit)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.PriceDis)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.DrawbackValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.CommissionValue)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.PostageFee2)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .Property(e => e.InsureValue)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<Wdgj_SaleOrder>()
                .HasMany(e => e.Wdgj_SaleOrderList)
                .WithRequired(e => e.Wdgj_SaleOrder)
                .WillCascadeOnDelete(false);

            modelBuilder.Entity<Wdgj_SaleOrderList>()
                .Property(e => e.SellPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrderList>()
                .Property(e => e.Score)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrderList>()
                .Property(e => e.GoodsCost)
                .HasPrecision(19, 4);

            modelBuilder.Entity<Wdgj_SaleOrderList>()
                .Property(e => e.SellTotal)
                .HasPrecision(19, 4);

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

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

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

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

            modelBuilder.Entity<Wdgj_StockIn>()
                .HasMany(e => e.Wdgj_StockInList)
                .WithRequired(e => e.Wdgj_StockIn)
                .WillCascadeOnDelete(false);

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

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

            modelBuilder.Entity<WDT_ExpressRelation>()
                .Property(e => e.ExpressCorpName)
                .IsFixedLength();

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

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

            modelBuilder.Entity<WDT_Product>()
                .Property(e => e.Price)
                .HasPrecision(19, 4);

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

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

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

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

            modelBuilder.Entity<WDT_SaleOrder>()
                .Property(e => e.GoodsTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<WDT_SaleOrder>()
                .Property(e => e.PostageTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<WDT_SaleOrder>()
                .Property(e => e.FavourableTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<WDT_SaleOrder>()
                .Property(e => e.AllTotal)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<WDT_SaleOrderList>()
                .Property(e => e.SellPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<WDT_SaleOrderList>()
                .Property(e => e.DiscountMoney)
                .HasPrecision(19, 4);

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

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

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

            modelBuilder.Entity<Webgistix_ApiOrder>()
                .HasMany(e => e.Webgistix_ApiOrderDetail)
                .WithOptional(e => e.Webgistix_ApiOrder)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Webgistix_AsnOrder>()
                .HasMany(e => e.Webgistix_AsnOrderDetail)
                .WithOptional(e => e.Webgistix_AsnOrder)
                .WillCascadeOnDelete();

            modelBuilder.Entity<Webgistix_SKU>()
                .Property(e => e.UnitPrice)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Webgistix_StoreInfo>()
                .Property(e => e.AppKey)
                .IsUnicode(false);

            modelBuilder.Entity<Webgistix_StoreInfo>()
                .Property(e => e.AppSecret)
                .IsUnicode(false);

            modelBuilder.Entity<WeiMeng_Order>()
                .Property(e => e.coupon_amount)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_Order>()
                .Property(e => e.real_amount)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_Order>()
                .Property(e => e.delivery_amount)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_Order>()
                .Property(e => e.goods_amount)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_OrderList>()
                .Property(e => e.sale_price)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_OrderList>()
                .Property(e => e.sale_amount)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_OrderList>()
                .Property(e => e.price)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_OrderList>()
                .Property(e => e.amount)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_Product>()
                .Property(e => e.low_sellprice)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_Product>()
                .Property(e => e.high_sellprice)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_Product>()
                .Property(e => e.low_marketprice)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_Product>()
                .Property(e => e.high_marketprice)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_ProductSKU>()
                .Property(e => e.sale_price)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_ProductSKU>()
                .Property(e => e.market_price)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_ProductSKU>()
                .Property(e => e.weight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_ProductSKU>()
                .Property(e => e.volume)
                .HasPrecision(18, 4);

            modelBuilder.Entity<WeiMeng_StoreInfo>()
                .Property(e => e.AppKey)
                .IsUnicode(false);

            modelBuilder.Entity<WeiMeng_StoreInfo>()
                .Property(e => e.AppSecret)
                .IsUnicode(false);

            modelBuilder.Entity<WeiMeng_StoreInfo>()
                .Property(e => e.AccessToken)
                .IsUnicode(false);

            modelBuilder.Entity<WeiMeng_StoreInfo>()
                .Property(e => e.MerchantAccount)
                .IsUnicode(false);

            modelBuilder.Entity<WeiMeng_StoreInfo>()
                .Property(e => e.UID)
                .IsUnicode(false);

            modelBuilder.Entity<WeiMeng_StoreInfo>()
                .Property(e => e.User_Nick)
                .IsUnicode(false);

            modelBuilder.Entity<WeiMeng_StoreInfo>()
                .Property(e => e.Token_Type)
                .IsUnicode(false);

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

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

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

            modelBuilder.Entity<Wish_StoreInfo>()
                .Property(e => e.PlatformCommission)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Wish_StoreInfo>()
                .Property(e => e.PayalCommission)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Wish_StoreInfo>()
                .Property(e => e.ExchangeRMB)
                .HasPrecision(19, 4);

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

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

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

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

            modelBuilder.Entity<Base_Trailer>()
                .Property(e => e.TotalQuality)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_Trailer>()
                .Property(e => e.ApprovedQuality)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_Trailer>()
                .Property(e => e.TempCoverage)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_Trailer>()
                .Property(e => e.InsuranceCoverage)
                .HasPrecision(18, 4);

            modelBuilder.Entity<Base_Trailer>()
                .Property(e => e.LogisticsInsurance)
                .HasPrecision(18, 4);

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

            modelBuilder.Entity<eBay_SKUOther_Relation>()
                .Property(e => e.ItemID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<eBay_SKUOther_Relation>()
                .Property(e => e.CharityID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<eBay_SKUOther_Relation>()
                .Property(e => e.FreeAddedCategory_ID)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<eBay_SKUOther_Relation>()
                .Property(e => e.PolicyText)
                .IsUnicode(false);

            modelBuilder.Entity<eBay_SKUOther_Relation>()
                .Property(e => e.ListingCheckoutRedirectPreference_ProStoresStoreName)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<eBay_SKUOther_Relation>()
                .Property(e => e.ListingCheckoutRedirectPreference_SellerThirdPartyUsername)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<eBay_SKUOther_Relation>()
                .Property(e => e.UnitInfo_UnitQuantity)
                .HasPrecision(18, 0);

            modelBuilder.Entity<Finance_PayableIncreaseList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<vAliExpress_Message>()
                .Property(e => e.MessageChannel)
                .IsUnicode(false);

            modelBuilder.Entity<vAliExpress_Message>()
                .Property(e => e.MessageType)
                .IsUnicode(false);

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

            modelBuilder.Entity<vBase_Client_Arrears>()
                .Property(e => e.CreditLine)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<vBase_Corp>()
                .Property(e => e.CorpType)
                .IsUnicode(false);

            modelBuilder.Entity<vBase_Order_Statistics_Curve>()
                .Property(e => e.TotalSales)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vBase_Order_Statistics_Curve>()
                .Property(e => e.EffectiveSales)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vBase_Order_Statistics_Curve>()
                .Property(e => e.InvalidSales)
                .HasPrecision(19, 4);

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<vBase_ProductInfo>()
                .Property(e => e.PlaceholderStorage)
                .HasPrecision(38, 4);

            modelBuilder.Entity<vBase_ProductInfo>()
                .Property(e => e.ProductStorage)
                .HasPrecision(38, 4);

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

            modelBuilder.Entity<vBase_ProductInfo>()
                .Property(e => e.marketPrice)
                .HasPrecision(19, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<vBase_ProductInfo_SKU>()
                .Property(e => e.SpecAlias)
                .IsUnicode(false);

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

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

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

            modelBuilder.Entity<vBase_ProductInfo_SKU>()
                .Property(e => e.marketPrice)
                .HasPrecision(19, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<vBase_ProductInfo_Storage>()
                .Property(e => e.DamagedPurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vBase_ProductInfo_Storage>()
                .Property(e => e.DamagedPurchaseMoney)
                .HasPrecision(19, 4);

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

            modelBuilder.Entity<vBase_ProductInfo_Storage>()
                .Property(e => e.SaleMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<vBase_ProductInfo_Storage>()
                .Property(e => e.SKUPurchasePrice)
                .HasPrecision(19, 4);

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<vBase_ProductPlaceHolder>()
                .Property(e => e.PlaceholderWeight)
                .HasPrecision(18, 6);

            modelBuilder.Entity<vBase_ProductPlaceHolder>()
                .Property(e => e.OrignHolderWeight)
                .HasPrecision(18, 6);

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

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

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

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

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

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

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

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

            modelBuilder.Entity<vBase_ProductPosition>()
                .Property(e => e.PlaceholderStorage)
                .HasPrecision(38, 4);

            modelBuilder.Entity<vBase_ProductPosition>()
                .Property(e => e.ValidQty)
                .HasPrecision(38, 4);

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

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

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

            modelBuilder.Entity<vBase_ProductPosition>()
                .Property(e => e.MinCapacity)
                .HasPrecision(18, 0);

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

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<vBase_ProductPosition_RealTime>()
                .Property(e => e.ActionStatus)
                .IsUnicode(false);

            modelBuilder.Entity<vBase_ProductPositionData>()
                .Property(e => e.ProductStorage)
                .HasPrecision(38, 4);

            modelBuilder.Entity<vBase_ProductPositionGroup>()
                .Property(e => e.ProductStorage)
                .HasPrecision(38, 4);

            modelBuilder.Entity<vBase_ProductPositionGroup>()
                .Property(e => e.OrignStorage)
                .HasPrecision(38, 4);

            modelBuilder.Entity<vBase_ProductPositionGroup>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(38, 19);

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

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

            modelBuilder.Entity<vBase_ProductPositionGroup>()
                .Property(e => e.RatePrice)
                .HasPrecision(38, 19);

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

            modelBuilder.Entity<vBase_ProductPositionGroup>()
                .Property(e => e.PlaceholderStorage)
                .HasPrecision(38, 4);

            modelBuilder.Entity<vBase_ProductPositionGroup>()
                .Property(e => e.ValidQuantity)
                .HasPrecision(38, 4);

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

            modelBuilder.Entity<vBase_ProductPositionGroup>()
                .Property(e => e.TotalWeight)
                .HasPrecision(38, 5);

            modelBuilder.Entity<vBase_ProductPositionGroup>()
                .Property(e => e.Weight)
                .HasPrecision(38, 6);

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

            modelBuilder.Entity<vBase_ProductPositionGroup>()
                .Property(e => e.ValidQty)
                .HasPrecision(38, 4);

            modelBuilder.Entity<vBase_ProductPositionGroup_Position>()
                .Property(e => e.ProductStorage)
                .HasPrecision(38, 4);

            modelBuilder.Entity<vBase_ProductPositionGroup_Position>()
                .Property(e => e.OrignStorage)
                .HasPrecision(38, 4);

            modelBuilder.Entity<vBase_ProductPositionGroup_Position>()
                .Property(e => e.ValidQuantity)
                .HasPrecision(38, 4);

            modelBuilder.Entity<vBase_ProductPositionGroup_Position>()
                .Property(e => e.PlaceholderStorage)
                .HasPrecision(38, 4);

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

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

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

            modelBuilder.Entity<vBase_StorageArea>()
                .Property(e => e.MaxWeight)
                .HasPrecision(14, 2);

            modelBuilder.Entity<vBase_StorageArea>()
                .Property(e => e.TotalWeight)
                .HasPrecision(38, 5);

            modelBuilder.Entity<vBase_StorageArea>()
                .Property(e => e.SurplusWeight)
                .HasPrecision(38, 5);

            modelBuilder.Entity<vBase_StorageArea>()
                .Property(e => e.DepositRate)
                .HasPrecision(27, 15);

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

            modelBuilder.Entity<vCRM_SaleQuotationList>()
                .Property(e => e.CreatePurchaseOrder)
                .IsUnicode(false);

            modelBuilder.Entity<veBay_SKU_Relation_SKU>()
                .Property(e => e.Description)
                .IsUnicode(false);

            modelBuilder.Entity<veBay_SKU_Relation_SKU>()
                .Property(e => e.ApplicationData)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<veBay_SKU_Relation_SKU>()
                .Property(e => e.ShipToLocations)
                .IsUnicode(false);

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<vExpress_BaseInfo>()
                .Property(e => e.AccountType)
                .IsUnicode(false);

            modelBuilder.Entity<vFee_StatWorkerByMonth>()
                .Property(e => e.ItemValue)
                .HasPrecision(38, 2);

            modelBuilder.Entity<vFee_StatWorkerByMonth>()
                .Property(e => e.UnitPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFee_StatWorkerByMonth>()
                .Property(e => e.TotalPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_BankAccount>()
                .Property(e => e.BalanceRMB)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_BankFeeList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_FeeList>()
                .Property(e => e.AmountMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<vFinance_Pay_Purchase_Adjustment>()
                .Property(e => e.PayablesTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_Pay_Purchase_Adjustment>()
                .Property(e => e.AdjustmentIncrease)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_Pay_Purchase_Adjustment>()
                .Property(e => e.AdjustmentReduction)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_Pay_PurchaseList_Adjustment>()
                .Property(e => e.BillType)
                .IsUnicode(false);

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

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

            modelBuilder.Entity<vFinance_Pay_PurchaseList_Adjustment>()
                .Property(e => e.TotalSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_Pay_PurchaseList_Adjustment>()
                .Property(e => e.TotalUnSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_Pay_PurchaseList_Adjustment>()
                .Property(e => e.FavourTotal)
                .HasPrecision(1, 1);

            modelBuilder.Entity<vFinance_Prepay_Surplus>()
                .Property(e => e.SurplusMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_Prereceive_Surplus>()
                .Property(e => e.SurplusMoney)
                .HasPrecision(19, 4);

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

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

            modelBuilder.Entity<vFinance_Receive_Adjustment>()
                .Property(e => e.AdjustmentIncrease)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_Receive_Adjustment>()
                .Property(e => e.AdjustmentReduction)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_ReceiveList_Adjustment>()
                .Property(e => e.BillType)
                .IsUnicode(false);

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

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

            modelBuilder.Entity<vFinance_ReceiveList_Adjustment>()
                .Property(e => e.TotalSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_ReceiveList_Adjustment>()
                .Property(e => e.TotalUnSettle)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vFinance_ReceiveList_Adjustment>()
                .Property(e => e.FavourTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vMagento_Order_Relation>()
                .Property(e => e.ResultStatus)
                .IsUnicode(false);

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

            modelBuilder.Entity<vPurchase_Enter_RankByDay>()
                .Property(e => e.Day)
                .IsFixedLength()
                .IsUnicode(false);

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

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

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

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

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

            modelBuilder.Entity<vPurchase_EnterList>()
                .Property(e => e.UnfinishedQuantity)
                .HasPrecision(14, 4);

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

            modelBuilder.Entity<vPurchase_EnterList>()
                .Property(e => e.PurchaseQty)
                .HasPrecision(14, 4);

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<vPurchase_EnterList_Report>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

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

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

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

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

            modelBuilder.Entity<vPurchase_ExchangeEnterList>()
                .Property(e => e.OuterTotalMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vPurchase_ExchangeEnterList>()
                .Property(e => e.DifferenceMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vPurchase_ExchangeEnterList>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vPurchase_ExchangeEnterList>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vPurchase_ExchangeEnterList>()
                .Property(e => e.PayMoney)
                .HasPrecision(19, 4);

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

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

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

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

            modelBuilder.Entity<vPurchase_ExchangeOuterList>()
                .Property(e => e.OuterTotalMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vPurchase_ExchangeOuterList>()
                .Property(e => e.DifferenceMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vPurchase_ExchangeOuterList>()
                .Property(e => e.FavourMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vPurchase_ExchangeOuterList>()
                .Property(e => e.FactMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vPurchase_ExchangeOuterList>()
                .Property(e => e.PayMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vPurchase_Order_Arrived>()
                .Property(e => e.ArrivedRate)
                .HasPrecision(10, 2);

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

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

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

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

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

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

            modelBuilder.Entity<vPurchase_OrderList>()
                .Property(e => e.FinishRate)
                .HasPrecision(33, 19);

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

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

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

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

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

            modelBuilder.Entity<vPurchase_OrderList>()
                .Property(e => e.UnEnterQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vPurchase_OrderList>()
                .Property(e => e.returnQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vPurchase_OrderList>()
                .Property(e => e.bigEnterQuantity)
                .HasPrecision(14, 4);

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

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

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

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

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

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

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

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

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

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

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

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

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

            modelBuilder.Entity<vPurchase_ShelveDetail>()
                .Property(e => e.quantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vPurchase_ShelveDetail>()
                .Property(e => e.plateCode)
                .IsUnicode(false);

            modelBuilder.Entity<vPurchase_ShelveDetail>()
                .Property(e => e.shelveCode)
                .IsUnicode(false);

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

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

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

            modelBuilder.Entity<vPurchase_ShelveList>()
                .Property(e => e.ShelveType)
                .IsUnicode(false);

            modelBuilder.Entity<vPurchase_ShelveList>()
                .Property(e => e.ShelveCode)
                .IsUnicode(false);

            modelBuilder.Entity<vPurchase_ShelveList>()
                .Property(e => e.ProductCode)
                .IsUnicode(false);

            modelBuilder.Entity<vPurchase_ShelveList>()
                .Property(e => e.ProductName)
                .IsUnicode(false);

            modelBuilder.Entity<vPurchase_ShelveList>()
                .Property(e => e.ProductModel)
                .IsUnicode(false);

            modelBuilder.Entity<vPurchase_ShelveList>()
                .Property(e => e.NetWeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<vPurchase_ShelveList>()
                .Property(e => e.PositionName)
                .IsUnicode(false);

            modelBuilder.Entity<vPurchase_ShelveList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<vPurchase_ShelveList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<vRequire_AllocationList>()
                .Property(e => e.ProductPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vRequire_AllocationList>()
                .Property(e => e.ProductTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vRequire_GoodsList>()
                .Property(e => e.ProductPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vRequire_GoodsList>()
                .Property(e => e.ProductTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ExchangeEnterList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ExchangeEnterList>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ExchangeEnterList>()
                .Property(e => e.SaleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ExchangeEnterList>()
                .Property(e => e.Rate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ExchangeEnterList>()
                .Property(e => e.RatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ExchangeEnterList>()
                .Property(e => e.RateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ExchangeOuterList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ExchangeOuterList>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ExchangeOuterList>()
                .Property(e => e.SaleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ExchangeOuterList>()
                .Property(e => e.Rate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ExchangeOuterList>()
                .Property(e => e.RatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ExchangeOuterList>()
                .Property(e => e.RateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalQuantityOrder)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalQuantityCanceled)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalQuantityInvoiced)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalQuantityRefunded)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalQuantityOuted)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalQuantityShipped)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.Weight)
                .HasPrecision(18, 3);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.MaterialCount)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseTaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseDiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseSubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseGrandTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseTotalPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseTotalUnPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseTotalRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseTotalCanceled)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseTotalInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseTotalOnlineRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseTotalOffRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.ShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.FactFreightRMB)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.DiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.GrandTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.Unpaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalCanceled)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalOnlineRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalOffRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.StoreBaseRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.StoreOrderRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseGlobalRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.BaseOrderRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.FavourAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalRateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<vSale_Order>()
                .Property(e => e.ValidQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.Weight)
                .HasPrecision(18, 3);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseTaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseDiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseSubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseGrandTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseTotalPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseTotalUnPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseTotalRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseTotalCanceled)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseTotalInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseTotalOnlineRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseTotalOffRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.TaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.ShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.FactFreightRMB)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.DiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.GrandTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.TotalPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.TotalRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.TotalCanceled)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.TotalInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.TotalOnlineRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.TotalOffRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.StoreBaseRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.StoreOrderRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseGlobalRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.BaseOrderRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.FavourAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_FactFreightRMB>()
                .Property(e => e.TotalRateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_ProductSplit>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_Order_ProductSplit>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_ProductSplit>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_ProductSplitList>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_Order_ProductSplitList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_ProductSplitList>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Stat>()
                .Property(e => e.GrandTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Stat>()
                .Property(e => e.TotalRateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Stat>()
                .Property(e => e.DiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Stat>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Stat>()
                .Property(e => e.TotalPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Stat>()
                .Property(e => e.ShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Stat>()
                .Property(e => e.Weight)
                .HasPrecision(18, 3);

            modelBuilder.Entity<vSale_Order_Stat>()
                .Property(e => e.TotalMoneyOuted)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Stat>()
                .Property(e => e.TotalWeight)
                .HasPrecision(38, 3);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.Weight)
                .HasPrecision(18, 3);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseTaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseDiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseSubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseGrandTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseTotalPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseTotalUnPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseTotalRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseTotalCanceled)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseTotalInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseTotalOnlineRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseTotalOffRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.TaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.ShippingAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.FactFreightRMB)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.DiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.GrandTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.TotalPaid)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.TotalRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.TotalCanceled)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.TotalInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.TotalOnlineRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.TotalOffRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.StoreBaseRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.StoreOrderRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseGlobalRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.BaseOrderRate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.FavourAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Order_Transfter>()
                .Property(e => e.TotalRateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderDetail>()
                .Property(e => e.QuantityOrder)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_OrderDetail>()
                .Property(e => e.QuantityShipped)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_OrderDetail>()
                .Property(e => e.validQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_OrderDetail>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderDetail>()
                .Property(e => e.outNumber)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.QuantityOrder)
                .HasPrecision(25, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.RowTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.RatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.RateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.DiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.QuantityOuted)
                .HasPrecision(25, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.OutboundAmount)
                .HasPrecision(38, 6);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.LackStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.ValidQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.RowPaid)
                .HasPrecision(18, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.AttachAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.DiscountRate)
                .HasPrecision(18, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.SalePriceDiscount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.NetWeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.QuantityRefunded)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 3);

            modelBuilder.Entity<vSale_OrderList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<vSale_OrderList_Client>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Client>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Client>()
                .Property(e => e.SalePriceDiscount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Client>()
                .Property(e => e.TaxBeforeDiscount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Client>()
                .Property(e => e.RowTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Lack>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_OrderList_Lack>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Lack>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Lack>()
                .Property(e => e.RowTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Lack>()
                .Property(e => e.RatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Lack>()
                .Property(e => e.RateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Replenishment>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_OrderList_Replenishment>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Replenishment>()
                .Property(e => e.RowTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Report>()
                .Property(e => e.PaidMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Report>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Report>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderList_Report>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_OrderPickingList>()
                .Property(e => e.Weight)
                .HasPrecision(38, 5);

            modelBuilder.Entity<vSale_OrderPickingList>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderPickToLight>()
                .Property(e => e.TaskProcess)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_OrderPickToLight>()
                .Property(e => e.TaskType)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_OrderPickToLight>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_OrderPlanDetail>()
                .Property(e => e.TotalQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_OrderPlanDetail>()
                .Property(e => e.TotalMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderPlanDetail>()
                .Property(e => e.Quantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_OrderPlanDetail>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderPlanDetail>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderPlanDetail>()
                .Property(e => e.SaleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OrderPlanDetail>()
                .Property(e => e.totalWeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<vSale_OrderPlanDetail>()
                .Property(e => e.CheckoutQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vSale_OrderPrintList>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_OrderPrintList_Group>()
                .Property(e => e.Weight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<vSale_OrderPrintList_Group>()
                .Property(e => e.TotalWeight)
                .HasPrecision(38, 5);

            modelBuilder.Entity<vSale_Outer_CaseList>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_Outer_CaseList>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Outer_CaseList>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Outer_CaseList>()
                .Property(e => e.RowTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_Outer_Loading>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.Rate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.RatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.RateAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.DiscountAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.DiscountRate)
                .HasPrecision(18, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.NetWeight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.RowTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.ShippingAmount)
                .HasPrecision(18, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.RowPaid)
                .HasPrecision(18, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.AttachAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.SalePriceDiscount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<vSale_OuterList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<vSale_OuterWrapper>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_OuterWrapper>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_OuterWrapper>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_RankByDay>()
                .Property(e => e.Day)
                .IsFixedLength()
                .IsUnicode(false);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.TotalMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.ReturnMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.Rate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.TotalRateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.OriginalPrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.TaxAmount)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.RowTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.RowInvoiced)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.RatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.RateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.AmountRefunded)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.BaseSubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 3);

            modelBuilder.Entity<vSale_ReturnList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<vSale_SendList_Report>()
                .Property(e => e.ProductSpec)
                .IsUnicode(false);

            modelBuilder.Entity<vSale_SendList_Report>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_SendList_Report>()
                .Property(e => e.SubTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_SendList_Report>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vSale_SendList_Report>()
                .Property(e => e.SubPurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStat_StorageDay>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStat_StorageDay>()
                .Property(e => e.PurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_AllocateApplyList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_AllocateApplyList>()
                .Property(e => e.PurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_AssembleOuterList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_AssembleOuterList>()
                .Property(e => e.PurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_BorrowEnterList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_BorrowEnterList>()
                .Property(e => e.EnterMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_BorrowEnterReturnList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_BorrowEnterReturnList>()
                .Property(e => e.EnterMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_BorrowEnterReturnList>()
                .Property(e => e.ReturnMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_BorrowOuterList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_BorrowOuterList>()
                .Property(e => e.OuterMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_CheckList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_CheckList>()
                .Property(e => e.PurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_CheckList>()
                .Property(e => e.ProfitMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_CheckList>()
                .Property(e => e.LossMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_LossList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_LossList>()
                .Property(e => e.PurchaseMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_LossList>()
                .Property(e => e.LossMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_OuterList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_OuterList>()
                .Property(e => e.SalePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_OuterList>()
                .Property(e => e.SaleMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_OuterList>()
                .Property(e => e.Rate)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_OuterList>()
                .Property(e => e.RatePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_OuterList>()
                .Property(e => e.RateMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_Plate>()
                .Property(e => e.PlateStatus)
                .IsUnicode(false);

            modelBuilder.Entity<vStorage_PositionTransferList>()
                .Property(e => e.PurchasePrice)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_ProfitLossList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(38, 6);

            modelBuilder.Entity<vStorage_ProfitLossList>()
                .Property(e => e.Weight)
                .HasPrecision(38, 6);

            modelBuilder.Entity<vStorage_ProfitLossList>()
                .Property(e => e.ProfitMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_ProfitLossList>()
                .Property(e => e.LossMoney)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vStorage_ProfitLossList>()
                .Property(e => e.ProfitWeight)
                .HasPrecision(38, 2);

            modelBuilder.Entity<vSys_Menu>()
                .Property(e => e.state)
                .IsUnicode(false);

            modelBuilder.Entity<vSys_User_Login>()
                .Property(e => e.UserType)
                .IsUnicode(false);

            modelBuilder.Entity<vTMS_Claim>()
                .Property(e => e.GrandTotal)
                .HasPrecision(18, 0);

            modelBuilder.Entity<vTMS_Claim>()
                .Property(e => e.ClaimAmount)
                .HasPrecision(18, 0);

            modelBuilder.Entity<vTMS_QuotationList>()
                .Property(e => e.TotalQuantityOrder)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vTMS_QuotationList>()
                .Property(e => e.GrandTotal)
                .HasPrecision(19, 4);

            modelBuilder.Entity<vTMS_QuotationList>()
                .Property(e => e.TotalWeight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<vTMS_QuotationList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 5);

            modelBuilder.Entity<vTMS_QuotationList>()
                .Property(e => e.InQuantity)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vTMS_WayBillList>()
                .Property(e => e.GrandTotal)
                .HasPrecision(18, 0);

            modelBuilder.Entity<vTMS_WayBillList>()
                .Property(e => e.SmallUnit)
                .IsFixedLength();

            modelBuilder.Entity<vTMS_WayBillList>()
                .Property(e => e.SalePrice)
                .HasPrecision(18, 0);

            modelBuilder.Entity<vTMS_WayBillList>()
                .Property(e => e.RowTotal)
                .HasPrecision(18, 0);

            modelBuilder.Entity<vTMS_WayBillList>()
                .Property(e => e.Weight)
                .HasPrecision(18, 4);

            modelBuilder.Entity<vvBase_ProductPosition>()
                .Property(e => e.OrignStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vvBase_ProductPosition>()
                .Property(e => e.ProductStorage)
                .HasPrecision(14, 4);

            modelBuilder.Entity<vWebgistix_Inventory>()
                .Property(e => e.CompareResult)
                .IsUnicode(false);
        }
    }

    //*/
}