Exemplo n.º 1
0
        public void Start()
        {
            EnumCodeMapper.AddMap <BusinessDataType>(new Dictionary <BusinessDataType, Int32> {
                { BusinessDataType.SO, 0 },
                { BusinessDataType.RMA, 1 },
                { BusinessDataType.CustomerMaster, 2 }
            });

            EnumCodeMapper.AddMap <ChangeType>(new Dictionary <ChangeType, string> {
                { ChangeType.Add, "A" },
                { ChangeType.Update, "U" },
                { ChangeType.Delete, "D" }
            });
        }
        public void Start()
        {
            EnumCodeMapper.AddMap <AmbassadorStatus>(new Dictionary <AmbassadorStatus, int>
            {
                { AmbassadorStatus.UnActive, 1 },
                { AmbassadorStatus.Active, 2 },
                { AmbassadorStatus.Canceled, 3 }
            });

            EnumCodeMapper.AddMap <UserType>(new Dictionary <UserType, int>
            {
                { UserType.NeweggAmbassador, 0 },
                { UserType.NeweggEmployee, 4 }
            });
        }
Exemplo n.º 3
0
        public void Start()
        {
            EnumCodeMapper.AddMap <RMAOwnBy>(new Dictionary <RMAOwnBy, int> {
                { RMAOwnBy.Origin, 0 },
                { RMAOwnBy.Customer, 1 },
                { RMAOwnBy.Self, 2 },
            });

            EnumCodeMapper.AddMap <RMALocation>(new Dictionary <RMALocation, int>
            {
                { RMALocation.Origin, 0 },
                { RMALocation.Self, 1 },
                { RMALocation.Vendor, 2 }
            });

            EnumCodeMapper.AddMap <SellersType>(new Dictionary <SellersType, string>
            {
                { SellersType.Self, "NEG" },
                { SellersType.Seller, "MET" }
            });
        }
Exemplo n.º 4
0
        public void Start()
        {
            EnumCodeMapper.AddMap <FeatureType>(new Dictionary <FeatureType, string> {
                { FeatureType.New, "N" },
                { FeatureType.Hot, "H" }
            });

            EnumCodeMapper.AddMap <GroupBuyingStatus>(new Dictionary <GroupBuyingStatus, string> {
                { GroupBuyingStatus.Init, "O" },
                { GroupBuyingStatus.WaitingAudit, "W" },
                { GroupBuyingStatus.VerifyFaild, "N" },
                { GroupBuyingStatus.Pending, "P" },
                { GroupBuyingStatus.WaitHandling, "R" },
                { GroupBuyingStatus.Active, "A" },
                { GroupBuyingStatus.Deactive, "D" },
                { GroupBuyingStatus.Finished, "F" }
            });
            EnumCodeMapper.AddMap <CountdownStatus>(new Dictionary <CountdownStatus, int> {
                { CountdownStatus.Abandon, -1 },
                { CountdownStatus.WaitForVerify, -3 },
                { CountdownStatus.VerifyFaild, -4 },
                { CountdownStatus.Ready, 0 },
                { CountdownStatus.Running, 1 },
                { CountdownStatus.Finish, 2 },
                { CountdownStatus.Interupt, -2 },
                { CountdownStatus.Init, -5 }
            });
            EnumCodeMapper.AddMap <ADStatus>(new Dictionary <ADStatus, string> {
                { ADStatus.Deactive, "D" },
                { ADStatus.Active, "A" }
            });
            EnumCodeMapper.AddMap <IsDefaultStatus>(new Dictionary <IsDefaultStatus, string> {
                { IsDefaultStatus.Deactive, "D" },
                { IsDefaultStatus.Active, "A" }
            });
            EnumCodeMapper.AddMap <ADTStatus>(new Dictionary <ADTStatus, string> {
                { ADTStatus.Deactive, "D" },
                { ADTStatus.Active, "A" },
                { ADTStatus.Test, "T" }
            });

            EnumCodeMapper.AddMap <RemarksType>(new Dictionary <RemarksType, string> {
                { RemarksType.Promotion, "R" },
                { RemarksType.Comment, "P" },
                { RemarksType.Discuss, "D" },
                { RemarksType.Consult, "C" }
            });

            EnumCodeMapper.AddMap <RemarkTypeShow>(new Dictionary <RemarkTypeShow, int> {
                { RemarkTypeShow.Auto, 0 },
                { RemarkTypeShow.Manual, -1 }
            });

            EnumCodeMapper.AddMap <YNStatus>(new Dictionary <YNStatus, string> {
                { YNStatus.No, "N" },
                { YNStatus.Yes, "Y" }
            });
            EnumCodeMapper.AddMap <IsDefaultShow>(new Dictionary <IsDefaultShow, string> {
                { IsDefaultShow.Show, "Y" },
                { IsDefaultShow.Hide, "N" }
            });
            EnumCodeMapper.AddMap <GroupBuyingStatusForNeweggg>(new Dictionary <GroupBuyingStatusForNeweggg, string> {
                { GroupBuyingStatusForNeweggg.WaitingAudit, "O" },
                { GroupBuyingStatusForNeweggg.Pending, "P" },
                { GroupBuyingStatusForNeweggg.Active, "A" },
                { GroupBuyingStatusForNeweggg.Finished, "F" },
                { GroupBuyingStatusForNeweggg.Deactive, "D" },
            });



            EnumCodeMapper.AddMap <BannerType>(new Dictionary <BannerType, string> {
                { BannerType.Image, "I" },
                { BannerType.Flash, "F" },
                { BannerType.HTML, "H" },
                { BannerType.Text, "T" },
                { BannerType.Video, "V" }
            });

            EnumCodeMapper.AddMap <ModuleType>(new Dictionary <ModuleType, int> {
                { ModuleType.Banner, 0 },
                { ModuleType.SEO, 1 },
                { ModuleType.ProductRecommend, 2 },
                { ModuleType.HotSale, 3 },
                { ModuleType.Poll, 4 },
                { ModuleType.HotKeywords, 5 },
                { ModuleType.DefaultKeywords, 6 }
            });

            EnumCodeMapper.AddMap <CouponsMKTType>(new Dictionary <CouponsMKTType, string>
            {
                { CouponsMKTType.MKTAFC, "F" },
                { CouponsMKTType.MKTAmbassador, "A" },
                { CouponsMKTType.MKTBD, "B" },
                { CouponsMKTType.MKTCS, "C" },
                { CouponsMKTType.MKTEmail, "M" },
                { CouponsMKTType.MKTInternal, "N" },
                { CouponsMKTType.MKTNetworkAlliance, "W" },
                { CouponsMKTType.MKTOffline, "L" },
                { CouponsMKTType.MKTOnline, "O" },
                { CouponsMKTType.MKTPM, "P" },
                { CouponsMKTType.MKTPlace, "S" }
            });

            EnumCodeMapper.AddMap <CouponsStatus>(new Dictionary <CouponsStatus, string>
            {
                { CouponsStatus.Finish, "F" },
                { CouponsStatus.Init, "O" },
                { CouponsStatus.Ready, "R" },
                { CouponsStatus.Run, "A" },
                { CouponsStatus.Void, "D" },
                { CouponsStatus.WaitingAudit, "W" },
                { CouponsStatus.Stoped, "S" }
            });

            EnumCodeMapper.AddMap <OpenAPIStatus>(new Dictionary <OpenAPIStatus, string>
            {
                { OpenAPIStatus.Active, "A" },
                { OpenAPIStatus.Deactive, "D" }
            });

            //公告及促销评论状态
            EnumCodeMapper.AddMap <NewsAdvReplyStatus>(new Dictionary <NewsAdvReplyStatus, int>
            {
                { NewsAdvReplyStatus.Show, 0 },
                { NewsAdvReplyStatus.SystemHide, -1 },
                { NewsAdvReplyStatus.HandHide, -2 }
            });

            EnumCodeMapper.AddMap <CouponsProductRangeType>(new Dictionary <CouponsProductRangeType, string>
            {
                { CouponsProductRangeType.AllProducts, "A" },
                { CouponsProductRangeType.LimitCategoryBrand, "X" },
                { CouponsProductRangeType.LimitProduct, "I" }
            });

            EnumCodeMapper.AddMap <CouponsBindConditionType>(new Dictionary <CouponsBindConditionType, string>
            {
                { CouponsBindConditionType.None, "A" },
                { CouponsBindConditionType.Rigester, "R" },
                { CouponsBindConditionType.Birthday, "B" },
                { CouponsBindConditionType.SO, "O" },
                { CouponsBindConditionType.Get, "L" }
                //{CouponsBindConditionType.Alipay,"Z"}
            });
            EnumCodeMapper.AddMap <CouponsValidPeriodType>(new Dictionary <CouponsValidPeriodType, int>
            {
                { CouponsValidPeriodType.All, 0 },
                { CouponsValidPeriodType.PublishDayToOneWeek, 1 },
                { CouponsValidPeriodType.PublishDayToOneMonth, 2 },
                { CouponsValidPeriodType.PublishDayToTwoMonths, 3 },
                { CouponsValidPeriodType.PublishDayToThreeMonths, 4 },
                { CouponsValidPeriodType.PublishDayToSixMonths, 5 },
                { CouponsValidPeriodType.CustomPeriod, 6 }
            });


            EnumCodeMapper.AddMap <CouponsRuleType>(new Dictionary <CouponsRuleType, string>
            {
                { CouponsRuleType.ProductDiscount, "D" }
            });

            EnumCodeMapper.AddMap <CouponCodeType>(new Dictionary <CouponCodeType, string>
            {
                { CouponCodeType.Common, "C" },
                { CouponCodeType.ThrowIn, "T" }
            });

            EnumCodeMapper.AddMap <CouponCodeUsedStatus>(new Dictionary <CouponCodeUsedStatus, string>
            {
                { CouponCodeUsedStatus.Active, "A" },
                { CouponCodeUsedStatus.Deactive, "D" }
            });

            EnumCodeMapper.AddMap <PSDiscountTypeForOrderAmount>(new Dictionary <PSDiscountTypeForOrderAmount, string>
            {
                { PSDiscountTypeForOrderAmount.OrderAmountDiscount, "D" },
                { PSDiscountTypeForOrderAmount.OrderAmountPercentage, "P" }
            });

            EnumCodeMapper.AddMap <PSDiscountTypeForProductPrice>(new Dictionary <PSDiscountTypeForProductPrice, string>
            {
                { PSDiscountTypeForProductPrice.ProductPriceDiscount, "Z" },
                { PSDiscountTypeForProductPrice.ProductPriceFinal, "F" }
            });

            EnumCodeMapper.AddMap <SOStatus>(new Dictionary <SOStatus, int>
            {
                { SOStatus.Split, -6 },
                { SOStatus.Abandon, -1 },
                { SOStatus.Origin, 0 },
                { SOStatus.WaitingOutStock, 1 },
                { SOStatus.Shipping, 10 },
                { SOStatus.WaitingManagerAudit, 3 },
                { SOStatus.OutStock, 4 },
                { SOStatus.Reported, 41 },
                { SOStatus.CustomsPass, 45 },
                { SOStatus.Complete, 5 },
                { SOStatus.Reject, 6 },
                { SOStatus.CustomsReject, 65 },
                { SOStatus.ShippingReject, 7 }
            });

            EnumCodeMapper.AddMap <CommentProcessStatus>(new Dictionary <CommentProcessStatus, int>
            {
                { CommentProcessStatus.Finish, 2 },
                { CommentProcessStatus.Handling, 1 },
                { CommentProcessStatus.Invalid, -1 },
                { CommentProcessStatus.WaitHandling, 0 }
            });
            EnumCodeMapper.AddMap <KeywordsStatus>(new Dictionary <KeywordsStatus, string>
            {
                { KeywordsStatus.All, "R" },
                { KeywordsStatus.Passed, "A" },
                { KeywordsStatus.Reject, "D" },
                { KeywordsStatus.Waiting, "O" }
            });
            EnumCodeMapper.AddMap <ReplyVendor>(new Dictionary <ReplyVendor, string>
            {
                { ReplyVendor.YES, "M" },
                { ReplyVendor.NO, "N" }
            });
            EnumCodeMapper.AddMap <PollType>(new Dictionary <PollType, string>
            {
                { PollType.Single, "S" },
                { PollType.Multiple, "M" },
                { PollType.ShortAnswer, "A" },
                { PollType.Other, "C" }
            });

            EnumCodeMapper.AddMap <SaleGiftStatus>(new Dictionary <SaleGiftStatus, string>
            {
                { SaleGiftStatus.Finish, "F" },
                { SaleGiftStatus.Init, "O" },
                { SaleGiftStatus.Ready, "R" },
                { SaleGiftStatus.Run, "A" },
                { SaleGiftStatus.Void, "D" },
                { SaleGiftStatus.WaitingAudit, "P" },
                { SaleGiftStatus.Stoped, "S" }
            });
            EnumCodeMapper.AddExtraCodeMap <SaleGiftStatus>(SaleGiftStatus.WaitingAudit, new object[] { "P", "W" });
            EnumCodeMapper.AddMap <SaleGiftType>(new Dictionary <SaleGiftType, string>
            {
                { SaleGiftType.Full, "F" },
                { SaleGiftType.Multiple, "M" },
                { SaleGiftType.Single, "S" },
                { SaleGiftType.Vendor, "V" },
                //{SaleGiftType.FirstOrder,"O"},
                //{SaleGiftType.Additional,"B"}
            });

            EnumCodeMapper.AddMap <SaleGiftDiscountBelongType>(new Dictionary <SaleGiftDiscountBelongType, string>
            {
                { SaleGiftDiscountBelongType.BelongGiftItem, "G" },
                { SaleGiftDiscountBelongType.BelongMasterItem, "M" }
            });

            EnumCodeMapper.AddMap <SaleGiftSaleRuleType>(new Dictionary <SaleGiftSaleRuleType, string>
            {
                { SaleGiftSaleRuleType.Brand, "B" },
                { SaleGiftSaleRuleType.BrandC3Combo, "C" },
                { SaleGiftSaleRuleType.C3, "L" },
                { SaleGiftSaleRuleType.Item, "I" }
            });


            EnumCodeMapper.AddMap <SaleGiftGiftItemType>(new Dictionary <SaleGiftGiftItemType, string>
            {
                { SaleGiftGiftItemType.GiftPool, "O" },
                { SaleGiftGiftItemType.AssignGift, "A" }
            });

            ///捆绑方式,是组合捆绑M还是交叉捆绑S
            EnumCodeMapper.AddMap <SaleGiftCombineType>(new Dictionary <SaleGiftCombineType, string>
            {
                { SaleGiftCombineType.Assemble, "M" },
                { SaleGiftCombineType.Cross, "S" }
            });

            EnumCodeMapper.AddMap <AndOrType>(new Dictionary <AndOrType, string>
            {
                { AndOrType.Or, "O" },
                { AndOrType.And, "A" },
                { AndOrType.Not, "N" }
            });


            EnumCodeMapper.AddMap <ThesaurusWordsType>(new Dictionary <ThesaurusWordsType, string>
            {
                { ThesaurusWordsType.Doubleaction, "T" },
                { ThesaurusWordsType.Monodirectional, "O" }
            });
            EnumCodeMapper.AddMap <KeywordsOperateUserType>(new Dictionary <KeywordsOperateUserType, int>
            {
                { KeywordsOperateUserType.Customer, 1 },
                { KeywordsOperateUserType.MKTUser, 0 }
            });

            EnumCodeMapper.AddMap <ComboStatus>(new Dictionary <ComboStatus, int>
            {
                { ComboStatus.Active, 0 },
                { ComboStatus.Deactive, -1 },
                { ComboStatus.WaitingAudit, 1 }
            });

            EnumCodeMapper.AddMap <ComboType>(new Dictionary <ComboType, int>
            {
                { ComboType.Common, 0 }
                //{ComboType.NYuanSend,1}
            });

            EnumCodeMapper.AddMap <GroupType>(new Dictionary <GroupType, int>
            {
                { GroupType.Custom, 2 },
                { GroupType.LevelOne, 3 },
                { GroupType.LevelTwo, 0 },
                { GroupType.LevelThree, 1 }
            });
            EnumCodeMapper.AddMap <AreaRelationType>(new Dictionary <AreaRelationType, string>
            {
                { AreaRelationType.Banner, "B" },
                { AreaRelationType.News, "N" }
            });

            EnumCodeMapper.AddMap <ShowType>(new Dictionary <ShowType, string>
            {
                { ShowType.Table, "T" },
                { ShowType.ImageText, "I" }
            });

            EnumCodeMapper.AddMap <RecommendType>(new Dictionary <RecommendType, int>
            {
                { RecommendType.Normal, 0 },
                //{RecommendType.Top,1},
                //{RecommendType.ShowRecommendIcon,2}
                //{RecommendType.FiveItemPerRow,3},
                //{RecommendType.EightItemLeft,4},
                //{RecommendType.EightItemRight,5},
                //{RecommendType.EightItemUpperLeft,6},
                { RecommendType.SixItemLeft, 7 }
            });

            //前台显示分类级别
            EnumCodeMapper.AddMap <ECCategoryLevel>(new Dictionary <ECCategoryLevel, string>
            {
                { ECCategoryLevel.Category1, "H" },
                { ECCategoryLevel.Category2, "M" },
                { ECCategoryLevel.Category3, "L" }
            });

            //产品价格举报状态
            EnumCodeMapper.AddMap <ProductPriceCompareStatus>(new Dictionary <ProductPriceCompareStatus, int>
            {
                { ProductPriceCompareStatus.WaitAudit, 0 },
                { ProductPriceCompareStatus.AuditPass, 1 },
                { ProductPriceCompareStatus.AuditDecline, 2 }
            });

            //产品价格举报DisplayLinkStatus
            EnumCodeMapper.AddMap <DisplayLinkStatus>(new Dictionary <DisplayLinkStatus, int>
            {
                { DisplayLinkStatus.Hide, 0 },
                { DisplayLinkStatus.Display, 1 }
            });
            EnumCodeMapper.AddMap <SaleAdvStatus>(new Dictionary <SaleAdvStatus, int>
            {
                { SaleAdvStatus.Active, 0 },
                { SaleAdvStatus.Deactive, -1 }
            });

            EnumCodeMapper.AddMap <GroupBuyingSettlementStatus>(new Dictionary <GroupBuyingSettlementStatus, string>
            {
                { GroupBuyingSettlementStatus.MoreThan, "C" },
                { GroupBuyingSettlementStatus.Yes, "Y" },
                { GroupBuyingSettlementStatus.No, "N" }
            });

            EnumCodeMapper.AddMap <GiftIsOnlineShow>(new Dictionary <GiftIsOnlineShow, string>
            {
                { GiftIsOnlineShow.Online, "Y" },
                { GiftIsOnlineShow.Deline, "N" }
            });
            EnumCodeMapper.AddMap <CouponLimitType>(new Dictionary <CouponLimitType, string>
            {
                { CouponLimitType.PanicBuying, "C" },
                { CouponLimitType.Kill, "K" },
                //{CouponLimitType.FriedEgg,"T"},
                { CouponLimitType.GroupBuying, "G" },
                { CouponLimitType.GiftCard, "L" },
                { CouponLimitType.Manually, "M" }
            });
            EnumCodeMapper.AddMap <ClearType>(new Dictionary <ClearType, string>
            {
                { ClearType.WaitClear, "W" },
                { ClearType.CompleteClear, "F" }
            });
            EnumCodeMapper.AddMap <DynamicCategoryType>(new Dictionary <DynamicCategoryType, Int32>
            {
                { DynamicCategoryType.Standard, 0 },
                { DynamicCategoryType.WangJie, 1 }
            });
            //EnumCodeMapper.AddMap<DynamicCategoryStatus>(new Dictionary<DynamicCategoryStatus, Int32>
            //{
            //    {DynamicCategoryStatus.Active,0},
            //    {DynamicCategoryStatus.Deactive,-1}
            //});

            //限购规则类型
            EnumCodeMapper.AddMap <LimitType>(new Dictionary <LimitType, Int32>
            {
                { LimitType.SingleProduct, 0 },
                { LimitType.Combo, 1 }
            });

            //限购规则状态
            EnumCodeMapper.AddMap <LimitStatus>(new Dictionary <LimitStatus, Int32>
            {
                { LimitStatus.Invalid, 0 },
                { LimitStatus.Valid, 1 }
            });

            //销售立减规则类型
            EnumCodeMapper.AddMap <SaleDiscountRuleType>(new Dictionary <SaleDiscountRuleType, Int32>
            {
                { SaleDiscountRuleType.AmountRule, 0 },
                { SaleDiscountRuleType.QtyRule, 1 }
            });

            //销售立减规则状态
            EnumCodeMapper.AddMap <SaleDiscountRuleStatus>(new Dictionary <SaleDiscountRuleStatus, Int32>
            {
                { SaleDiscountRuleStatus.Invalid, 0 },
                { SaleDiscountRuleStatus.Valid, 1 }
            });
            //销售立减规则状态
            EnumCodeMapper.AddMap <GroupBuyingCategoryType>(new Dictionary <GroupBuyingCategoryType, Int32>
            {
                { GroupBuyingCategoryType.Physical, 0 },
                { GroupBuyingCategoryType.Virtual, 1 },
                { GroupBuyingCategoryType.ZeroLottery, 2 }
            });
            EnumCodeMapper.AddMap <GroupBuyingFeedbackStatus>(new Dictionary <GroupBuyingFeedbackStatus, Int32>
            {
                { GroupBuyingFeedbackStatus.UnRead, 0 },
                { GroupBuyingFeedbackStatus.Readed, 1 }
            });
            EnumCodeMapper.AddMap <BusinessCooperationStatus>(new Dictionary <BusinessCooperationStatus, Int32>
            {
                { BusinessCooperationStatus.UnHandled, 0 },
                { BusinessCooperationStatus.Handled, 1 }
            });
            EnumCodeMapper.AddMap <SettlementBillStatus>(new Dictionary <SettlementBillStatus, Int32>
            {
                { SettlementBillStatus.UnSettle, 0 },
                { SettlementBillStatus.Settled, 1 }
            });
            EnumCodeMapper.AddMap <GroupBuyingCategoryStatus>(new Dictionary <GroupBuyingCategoryStatus, Int32>
            {
                { GroupBuyingCategoryStatus.Valid, 0 },
                { GroupBuyingCategoryStatus.InValid, -1 }
            });
        }
Exemplo n.º 5
0
        public void Start()
        {
            EnumCodeMapper.AddMap(new Dictionary <ValidStatus, string>
            {
                { ValidStatus.Active, "A" },
                { ValidStatus.DeActive, "D" }
            });


            EnumCodeMapper.AddMap(new Dictionary <ProductType, string>
            {
                { ProductType.Normal, "O" },
                { ProductType.OpenBox, "S" },
                { ProductType.Bad, "B" },
                { ProductType.Virtual, "V" }
            });

            EnumCodeMapper.AddMap(new Dictionary <Large, string>
            {
                { Large.Yes, "Y" },
                { Large.No, "N" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductGroupImageShow, string>
            {
                { ProductGroupImageShow.Yes, "Y" },
                { ProductGroupImageShow.No, "N" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductGroupPolymeric, string>
            {
                { ProductGroupPolymeric.Yes, "Y" },
                { ProductGroupPolymeric.No, "N" }
            });

            EnumCodeMapper.AddExtraCodeMap(ProductGroupPolymeric.No, new object[] { "n" });

            EnumCodeMapper.AddMap(new Dictionary <PropertyStatus, int>
            {
                { PropertyStatus.Active, 1 },
                { PropertyStatus.DeActive, 0 }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductAccessoryStatus, int>
            {
                { ProductAccessoryStatus.Active, 0 },
                { ProductAccessoryStatus.DeActive, -1 }
            });
            EnumCodeMapper.AddMap(new Dictionary <PropertyType, string>
            {
                { PropertyType.Grouping, "G" },
                { PropertyType.Other, "A" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductPropertyRequired, int>
            {
                { ProductPropertyRequired.Yes, 1 },
                { ProductPropertyRequired.No, 0 }
            });

            EnumCodeMapper.AddExtraCodeMap(PropertyType.Other, new object[] { "O" });
            EnumCodeMapper.AddMap(new Dictionary <ProductResourceStatus, string>
            {
                { ProductResourceStatus.Active, "A" },
                { ProductResourceStatus.DeActive, "D" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductResourceIsShow, string>
            {
                { ProductResourceIsShow.Yes, "Y" },
                { ProductResourceIsShow.No, "N" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ResourcesType, string>
            {
                { ResourcesType.Image, "I" },
                { ResourcesType.Image360, "D" },
                { ResourcesType.Video, "V" }
            });

            EnumCodeMapper.AddMap(new Dictionary <IsLarge, string>
            {
                { IsLarge.Yes, "L" },
                { IsLarge.No, "S" },
                { IsLarge.Undefined, "-" }
            });

            EnumCodeMapper.AddMap(new Dictionary <OfferVATInvoice, int>
            {
                { OfferVATInvoice.Yes, 1 },
                { OfferVATInvoice.No, 0 }
            });


            EnumCodeMapper.AddMap(new Dictionary <WarrantyShow, int>
            {
                { WarrantyShow.Yes, 1 },
                { WarrantyShow.No, 0 }
            });
            EnumCodeMapper.AddMap(new Dictionary <CustomerRank, int>
            {
                { CustomerRank.Ferrum, 1 },
                { CustomerRank.Copper, 2 },
                { CustomerRank.Silver, 3 },
                { CustomerRank.Golden, 4 },
                { CustomerRank.Diamond, 5 },
                { CustomerRank.Crown, 6 },
                { CustomerRank.Supremacy, 7 }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductRankPriceStatus, int>
            {
                { ProductRankPriceStatus.Active, 0 },
                { ProductRankPriceStatus.DeActive, -1 }
            });

            EnumCodeMapper.AddMap(new Dictionary <WholeSaleLevelType, int>
            {
                { WholeSaleLevelType.L1, 1 },
                { WholeSaleLevelType.L2, 2 },
                { WholeSaleLevelType.L3, 3 }
            });
            EnumCodeMapper.AddMap(new Dictionary <GiftCardStatus, string>
            {
                { GiftCardStatus.ManualActive, "H" },
                { GiftCardStatus.InValid, "D" },
                { GiftCardStatus.Void, "V" },
                { GiftCardStatus.Used, "U" },
                { GiftCardStatus.Valid, "A" }
            });
            EnumCodeMapper.AddMap(new Dictionary <CategoryExtendWarrantyStatus, string>
            {
                { CategoryExtendWarrantyStatus.Active, "A" },
                { CategoryExtendWarrantyStatus.DeActive, "D" }
            });

            EnumCodeMapper.AddMap(new Dictionary <CategoryExtendWarrantyDisuseBrandStatus, string>
            {
                { CategoryExtendWarrantyDisuseBrandStatus.Active, "A" },
                { CategoryExtendWarrantyDisuseBrandStatus.DeActive, "D" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ActionType, string>
            {
                { ActionType.Hold, "Hold" },
                { ActionType.AdjustExpireDate, "AdjustExpireDate" },
                { ActionType.ForwardCard, "ForwardCard" },
                { ActionType.MandatoryVoid, "MandatoryVoid" },
                { ActionType.UnHold, "UnHold" },
                { ActionType.SO, "SO" },
                { ActionType.RMA, "RMA" },
                { ActionType.ROBalance, "ROBalance" }
            });

            EnumCodeMapper.AddMap(new Dictionary <SellerProductRequestStatus, string>
            {
                { SellerProductRequestStatus.Approved, "A" },
                { SellerProductRequestStatus.Processing, "P" },
                { SellerProductRequestStatus.UnApproved, "D" },
                { SellerProductRequestStatus.WaitApproval, "O" },
                { SellerProductRequestStatus.Finish, "F" }
            });

            EnumCodeMapper.AddMap(new Dictionary <SellerProductRequestType, string>
            {
                { SellerProductRequestType.NewCreated, "N" },
                { SellerProductRequestType.ParameterUpdate, "P" },
                { SellerProductRequestType.ImageAndDescriptionUpdate, "I" }
            });

            EnumCodeMapper.AddMap(new Dictionary <SellerProductRequestTakePictures, string>
            {
                { SellerProductRequestTakePictures.Yes, "Y" },
                { SellerProductRequestTakePictures.No, "N" }
            });

            EnumCodeMapper.AddMap(new Dictionary <SellerProductRequestFileType, string>
            {
                { SellerProductRequestFileType.Image, "I" },
                { SellerProductRequestFileType.Text, "P" }
            });

            EnumCodeMapper.AddMap(new Dictionary <SellerProductRequestFileStatus, string>
            {
                { SellerProductRequestFileStatus.WaitProcess, "O" },
                { SellerProductRequestFileStatus.Finish, "F" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductPriceRequestStatus, int>
            {
                { ProductPriceRequestStatus.Origin, 0 },
                { ProductPriceRequestStatus.Approved, 1 },
                { ProductPriceRequestStatus.Deny, -1 },
                { ProductPriceRequestStatus.Canceled, -2 },
                { ProductPriceRequestStatus.NeedSeniorApprove, 9 },
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductPriceRequestAuditType, string>
            {
                { ProductPriceRequestAuditType.Audit, "T" },
                { ProductPriceRequestAuditType.SeniorAudit, "P" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductIsTakePicture, string>
            {
                { ProductIsTakePicture.Yes, "Y" },
                { ProductIsTakePicture.No, "N" }
            });

            EnumCodeMapper.AddMap(new Dictionary <SellerProductRequestOfferInvoice, string>
            {
                { SellerProductRequestOfferInvoice.Yes, "Y" },
                { SellerProductRequestOfferInvoice.No, "N" }
            });
            EnumCodeMapper.AddMap(new Dictionary <ProductStatus, int>
            {
                { ProductStatus.Abandon, -1 },
                { ProductStatus.Active, 1 },
                { ProductStatus.InActive_Show, 0 },
                { ProductStatus.InActive_UnShow, 2 }
            });
            EnumCodeMapper.AddMap(new Dictionary <IsDefault, int>
            {
                { IsDefault.Active, 0 },
                { IsDefault.DeActive, 1 }
            });

            EnumCodeMapper.AddMap(new Dictionary <TimelyPromotionTitleStatus, string>
            {
                { TimelyPromotionTitleStatus.Original, "O" },
                { TimelyPromotionTitleStatus.Active, "A" },
                { TimelyPromotionTitleStatus.DeActive, "D" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductIsVirtualPic, string>
            {
                { ProductIsVirtualPic.Yes, "Y" },
                { ProductIsVirtualPic.No, "N" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductIsAccessoryShow, string>
            {
                { ProductIsAccessoryShow.Yes, "Y" },
                { ProductIsAccessoryShow.No, "N" }
            });

            EnumCodeMapper.AddMap(new Dictionary <NotifyStatus, int>
            {
                { NotifyStatus.NotifyYes, 1 },
                { NotifyStatus.NotifyBad, -1 },
                { NotifyStatus.NotifyNo, 0 }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductInfoFinishStatus, string>
            {
                { ProductInfoFinishStatus.Yes, "Y" },
                { ProductInfoFinishStatus.No, "N" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ThirdPartner, string>
            {
                { ThirdPartner.Hengzhong, "H" },
                { ThirdPartner.Xijie, "X" },
                { ThirdPartner.Belle, "B" },
                { ThirdPartner.Yieke, "Y" },
                { ThirdPartner.Ingrammicro, "I" }
            });

            EnumCodeMapper.AddExtraCodeMap(new Dictionary <StockRules, object[]>
            {
                { StockRules.Limit, new object[] { "L" } },
                { StockRules.Direct, new object[] { "U" } },
                { StockRules.Customer, new object[] { "C", "T", "D" } },
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductMappingStatus, string>
            {
                { ProductMappingStatus.Active, "A" },
                { ProductMappingStatus.DeActive, "D" }
            });

            EnumCodeMapper.AddMap(new Dictionary <IsUseAlipayVipPrice, string>
            {
                { IsUseAlipayVipPrice.Yes, "Y" },
                { IsUseAlipayVipPrice.No, "N" }
            });

            EnumCodeMapper.AddMap(new Dictionary <IsAutoAdjustPrice, int>
            {
                { IsAutoAdjustPrice.Yes, 1 },
                { IsAutoAdjustPrice.No, 0 }
            });
            EnumCodeMapper.AddMap(new Dictionary <InventorySync, string>
            {
                { InventorySync.Yes, "Y" },
                { InventorySync.No, "N" }
            });
            EnumCodeMapper.AddMap(new Dictionary <BooleanEnum, string>
            {
                { BooleanEnum.Yes, "Y" },
                { BooleanEnum.No, "N" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductChannelInfoStatus, string>
            {
                { ProductChannelInfoStatus.Active, "A" },
                { ProductChannelInfoStatus.DeActive, "D" }
            });

            EnumCodeMapper.AddMap(new Dictionary <ProductChannelPeriodPriceStatus, string>
            {
                { ProductChannelPeriodPriceStatus.Finish, "F" },
                { ProductChannelPeriodPriceStatus.Init, "O" },
                { ProductChannelPeriodPriceStatus.Abandon, "D" },
                { ProductChannelPeriodPriceStatus.Ready, "R" },
                { ProductChannelPeriodPriceStatus.Running, "A" },
                { ProductChannelPeriodPriceStatus.WaitApproved, "P" }
            });
            EnumCodeMapper.AddMap(new Dictionary <AuthorizedStatus, string>
            {
                { AuthorizedStatus.Active, "A" },
                { AuthorizedStatus.DeActive, "D" }
            });

            EnumCodeMapper.AddMap(new Dictionary <UnicomContractPhoneNumberStatus, string>
            {
                { UnicomContractPhoneNumberStatus.Active, "A" },
                { UnicomContractPhoneNumberStatus.DeActive, "D" },
                { UnicomContractPhoneNumberStatus.CreateOrder, "S" }
            });
            EnumCodeMapper.AddMap(new Dictionary <CategoryTemplateType, int>
            {
                { CategoryTemplateType.TemplateProductTitle, 0 },
                { CategoryTemplateType.TemplateProductDescription, 1 },
                { CategoryTemplateType.TemplateProductName, 2 },
                { CategoryTemplateType.TemplateWeb, 3 }
            });
            EnumCodeMapper.AddMap(new Dictionary <RmaPolicyType, string>
            {
                { RmaPolicyType.DiscountType, "D" },
                { RmaPolicyType.ExtendType, "E" },
                { RmaPolicyType.ManufacturerType, "M" },
                { RmaPolicyType.StandardType, "P" },
                { RmaPolicyType.SellerType, "S" }
            });
            EnumCodeMapper.AddMap(new Dictionary <RmaPolicyStatus, string>
            {
                { RmaPolicyStatus.Active, "A" },
                { RmaPolicyStatus.DeActive, "D" },
            });
            EnumCodeMapper.AddMap(new Dictionary <IsOnlineRequst, string>
            {
                { IsOnlineRequst.YES, "Y" },
                { IsOnlineRequst.NO, "N" },
            });
            EnumCodeMapper.AddMap(new Dictionary <RmaLogActionType, string>
            {
                { RmaLogActionType.Create, "C" },
                { RmaLogActionType.Active, "A" },
                { RmaLogActionType.DeActive, "D" },
                { RmaLogActionType.Edit, "E" },
            });

            EnumCodeMapper.AddMap(new Dictionary <CollectDateType, string>
            {
                { CollectDateType.ExpiredDate, "E" },
                { CollectDateType.ManufactureDate, "P" }
            });

            EnumCodeMapper.AddMap(new Dictionary <GiftVoucherRelateProductStatus, string>
            {
                { GiftVoucherRelateProductStatus.Active, "A" },
                { GiftVoucherRelateProductStatus.Deactive, "D" }
            });

            EnumCodeMapper.AddMap(new Dictionary <GiftVoucherProductStatus, int>
            {
                { GiftVoucherProductStatus.AuditFail, -2 },
                { GiftVoucherProductStatus.Void, -1 },
                { GiftVoucherProductStatus.WaittingAudit, 1 },
                { GiftVoucherProductStatus.Audit, 2 }
            });

            EnumCodeMapper.AddMap(new Dictionary <GVRReqType, int>
            {
                { GVRReqType.Add, 0 },
                { GVRReqType.Delete, 1 }
            });

            EnumCodeMapper.AddMap(new Dictionary <GVRReqAuditStatus, string>
            {
                { GVRReqAuditStatus.AuditWaitting, "W" },
                { GVRReqAuditStatus.AuditFailed, "F" },
                { GVRReqAuditStatus.AuditSuccess, "S" }
            });
        }
Exemplo n.º 6
0
        public void Start()
        {
            //EnumCodeMapper.AddMap<CustomerType>(new Dictionary<CustomerType, int>{
            //    { CustomerType.Personal, 0 },
            //    { CustomerType.Enterprise, 1 },
            //    { CustomerType.EnterpriseUnVerify, -1 },
            //    { CustomerType.Campus, 2 },
            //    { CustomerType.CampusUnVerify, -2 }
            //});

            //EnumCodeMapper.AddMap<AgentType>(new Dictionary<AgentType, string>{
            //    { AgentType.Personal, "P" },
            //    { AgentType.Enterprise, "E" },
            //    { AgentType.Campus, "C" }
            //});
            EnumCodeMapper.AddMap <DepartmentValidStatus>(new Dictionary <DepartmentValidStatus, string> {
                { DepartmentValidStatus.Active, "A" },
                { DepartmentValidStatus.DeActive, "D" }
            });

            EnumCodeMapper.AddMap <BizOperationUserType>(new Dictionary <BizOperationUserType, string> {
                { BizOperationUserType.InUser, "I" },
                { BizOperationUserType.EditUser, "E" },
                { BizOperationUserType.ConfirmUser, "C" },
                { BizOperationUserType.ApprovedUser, "A" },
                { BizOperationUserType.User, "U" },
                { BizOperationUserType.PM, "P" },
                { BizOperationUserType.RecvUserSysNo, "R" }
            });

            EnumCodeMapper.AddMap <BizOperationUserStatus>(new Dictionary <BizOperationUserStatus, int> {
                { BizOperationUserStatus.Active, 0 },
                { BizOperationUserStatus.InActive, -1 }
            });

            EnumCodeMapper.AddMap <HYNStatus>(new Dictionary <HYNStatus, string> {
                { HYNStatus.Hide, "Hide" },
                { HYNStatus.No, "No" },
                { HYNStatus.Yes, "Yes" }
            });

            EnumCodeMapper.AddMap <SYNStatus>(new Dictionary <SYNStatus, string> {
                { SYNStatus.No, "No" },
                { SYNStatus.Yes, "Yes" }
            });
            EnumCodeMapper.AddMap <IsSpecial>(new Dictionary <IsSpecial, string> {
                { IsSpecial.No, "N" },
                { IsSpecial.Yes, "Y" }
            });
            EnumCodeMapper.AddMap <DeliveryStatusFor24H>(new Dictionary <DeliveryStatusFor24H, string> {
                { DeliveryStatusFor24H.No, "0" },
                { DeliveryStatusFor24H.Yes, "24H" }
            });
            EnumCodeMapper.AddMap <AreaStatus>(new Dictionary <AreaStatus, int> {
                { AreaStatus.Active, 0 },
                { AreaStatus.Deactive, -1 }
            });
            EnumCodeMapper.AddMap <ShipTypeProductType>(new Dictionary <ShipTypeProductType, string> {
                { ShipTypeProductType.Required, "D" },
                { ShipTypeProductType.Embargo, "E" }
            });
            EnumCodeMapper.AddMap <ProductRange>(new Dictionary <ProductRange, string> {
                { ProductRange.Goods, "P" },
                { ProductRange.GoodsType, "C" }
            });
            EnumCodeMapper.AddMap <CompanyCustomer>(new Dictionary <CompanyCustomer, int> {
                { CompanyCustomer.Default, 0 },
                { CompanyCustomer.AstraZeneca, 1 }
            });

            EnumCodeMapper.AddMap <LogSOStatus>(new Dictionary <LogSOStatus, int> {
                { LogSOStatus.Origin, 0 },
                { LogSOStatus.WaitingOutStock, 1 },
                { LogSOStatus.WaitingPay, 2 },
                { LogSOStatus.WaitingManagerAudit, 3 },
                { LogSOStatus.OutStock, 4 },
                { LogSOStatus.SystemCancel, -4 },
                { LogSOStatus.ManagerCancel, -3 },
                { LogSOStatus.CustomerCancel, -2 },
                { LogSOStatus.EmployeeCancel, -1 }
            });

            EnumCodeMapper.AddMap <c.BizLogType>(new Dictionary <c.BizLogType, int> {
                { c.BizLogType.St_Transfer_Item_Delete, 50143 },
                { c.BizLogType.RMA_Refund_CancelAudit, 70505 },
                { c.BizLogType.Sys_User_Add, 101010 },
                { c.BizLogType.Sys_User_Update, 101011 },
                { c.BizLogType.Sys_User_Login, 101012 },
                { c.BizLogType.Sys_Role_Add, 101110 },
                { c.BizLogType.Sys_Role_Update, 101111 },
                { c.BizLogType.Sys_UserRole_Add, 101210 },
                { c.BizLogType.Sys_UserRole_Delete, 101212 },
                { c.BizLogType.Sys_RolePrivilege_Add, 101310 },
                { c.BizLogType.Sys_RolePrivilege_Delete, 101312 },
                { c.BizLogType.Basic_Category1_Add, 111310 },
                { c.BizLogType.Basic_Category1_Update, 111311 },
                { c.BizLogType.Basic_Category1_CancelAudit, 111313 },
                { c.BizLogType.Basic_Category1_Approved, 111314 },
                { c.BizLogType.Basic_Category1_Declined, 111315 },
                { c.BizLogType.Basic_Category2_Add, 111410 },
                { c.BizLogType.Basic_Category2_Update, 111411 },
                { c.BizLogType.Basic_Category2_CancelAudit, 111413 },
                { c.BizLogType.Basic_Category2_Approved, 111414 },
                { c.BizLogType.Basic_Category2_Declined, 111415 },
                { c.BizLogType.Basic_Category3_Add, 111510 },
                { c.BizLogType.Basic_Category3_Update, 111511 },
                { c.BizLogType.Basic_Category3_CancelAudit, 111513 },
                { c.BizLogType.Basic_Category3_Approved, 111514 },
                { c.BizLogType.Basic_Category3_Declined, 111515 },
                { c.BizLogType.Basic_CategoryAttribute_Init, 111610 },
                { c.BizLogType.Basic_CategoryAttribute_Update, 111611 },
                { c.BizLogType.Basic_CategoryAttribute_Top, 111612 },
                { c.BizLogType.Basic_CategoryAttribute_Up, 111613 },
                { c.BizLogType.Basic_CategoryAttribute_Down, 111614 },
                { c.BizLogType.Basic_CategoryAttribute_Bottom, 111615 },
                { c.BizLogType.Basic_Manufacturer_Add, 111710 },
                { c.BizLogType.Basic_Manufacturer_Update, 111711 },
                { c.BizLogType.Basic_Vendor_Add, 111810 },
                { c.BizLogType.Basic_Vendor_Update, 111811 },
                { c.BizLogType.Basic_Vendor_Hold, 111812 },
                { c.BizLogType.Basic_Vendor_UnHold, 111813 },
                { c.BizLogType.Basic_Stock_Add, 111910 },
                { c.BizLogType.Basic_Stock_Update, 111911 },
                { c.BizLogType.Basic_Currency_Add, 112010 },
                { c.BizLogType.Basic_Currency_Update, 112011 },
                { c.BizLogType.Basic_Customer_Add, 113001 },
                { c.BizLogType.Basic_Product_Basic_Update, 113002 },
                { c.BizLogType.Basic_Product_Price_Update, 113003 },
                { c.BizLogType.Basic_Product_PM_Update, 113004 },
                { c.BizLogType.Basic_Product_Attribute_Update, 113005 },
                { c.BizLogType.Basic_Product_Weight_Update, 113006 },
                { c.BizLogType.Basic_Product_Pic_Update, 113007 },
                { c.BizLogType.Basic_Product_NotPermitRefund, 113008 },
                { c.BizLogType.Basic_Product_PermitRefund, 113009 },
                { c.BizLogType.Basic_Product_JDItem_Update, 113010 },
                { c.BizLogType.Ex_Product_TakePictures_Update, 113011 },
                { c.BizLogType.Basic_Customer_Invalid, 113012 },
                { c.BizLogType.Basic_Customer_ManualSetVIPRank, 113013 },
                { c.BizLogType.Basic_Product_Clone, 113014 },
                { c.BizLogType.Basic_Product_Copy, 113015 },
                { c.BizLogType.Basic_Product_Note_Update, 113017 },
                { c.BizLogType.Basic_Product_Hold_Update, 113018 },
                { c.BizLogType.Inventory_PurchaseQtyAdjust, 113019 },
                { c.BizLogType.Basic_Product_Price_Update_Verify, 113020 },
                { c.BizLogType.Basic_Product_Price_Update_CancelVerify, 113021 },
                { c.BizLogType.Basic_Product_Price_Update_VerifyOK, 113022 },
                { c.BizLogType.Basic_Product_Price_Update_VerifyCancel, 113023 },
                { c.BizLogType.Basic_Product_Info_PublishOK, 113024 },
                { c.BizLogType.Basic_Product_UnitCost_Update_Instalment, 113025 },
                { c.BizLogType.Basic_Product_Price_Update_Instalment, 113026 },
                { c.BizLogType.Basic_Product_Price_PMRequestMemo, 113030 },
                { c.BizLogType.Basic_Product_Price_TLRequestMemo, 113031 },
                { c.BizLogType.Basic_Product_TopCancelWithGoDown, 113041 },
                { c.BizLogType.Basic_Product_TopSave, 113042 },
                { c.BizLogType.Basic_Product_TopCancel, 113043 },
                { c.BizLogType.Vendor_Update_Verify, 114020 },
                { c.BizLogType.Vendor_Update_Cancel_Verify, 114021 },
                { c.BizLogType.Vendor_Update_VerifyOK, 114022 },
                { c.BizLogType.Vendor_Update__VerifyCancel, 114023 },
                { c.BizLogType.Basic_Area_Add, 116010 },
                { c.BizLogType.Basic_Area_Update, 116011 },
                { c.BizLogType.Basic_PayType_Add, 116012 },
                { c.BizLogType.Basic_PayType_Update, 116013 },
                { c.BizLogType.Basic_ShipType_Add, 116014 },
                { c.BizLogType.Basic_ShipType_Update, 116015 },
                { c.BizLogType.Basic_ShipAreaUn_Add, 116016 },
                { c.BizLogType.Basic_ShipAreaUn_Delete, 116017 },
                { c.BizLogType.Basic_ShipPayUn_Add, 116018 },
                { c.BizLogType.Basic_ShipPayUn_Delete, 116019 },
                { c.BizLogType.Basic_ShipAreaPrice_Add, 116020 },
                { c.BizLogType.Basic_ShipAreaPrice_Delete, 116021 },
                { c.BizLogType.Purchase_Basket_Insert, 201010 },
                { c.BizLogType.Purchase_Basket_Update, 201011 },
                { c.BizLogType.Purchase_Basket_Delete, 201012 },
                { c.BizLogType.Purchase_Create, 201110 },
                { c.BizLogType.Purchase_Master_Update, 201111 },
                { c.BizLogType.Purchase_Item_Insert, 201112 },
                { c.BizLogType.Purchase_Item_Update, 201113 },
                { c.BizLogType.Purchase_Item_Delete, 201114 },
                { c.BizLogType.Purchase_Verify_InStock, 201116 },
                { c.BizLogType.Purchase_CancelVerify, 201117 },
                { c.BizLogType.Purchase_InStock, 201118 },
                { c.BizLogType.Purchase_CancelInStock, 201119 },
                { c.BizLogType.Purchase_Abandon, 201120 },
                { c.BizLogType.Purchase_CancelAbandon, 201121 },
                { c.BizLogType.Purchase_ApportionMaster_Add, 201122 },
                { c.BizLogType.Purchase_ApportionMaster_Delete, 201123 },
                { c.BizLogType.Purchase_ApportionItem_Add, 201124 },
                { c.BizLogType.Purchase_ApportionItem_Delete, 201125 },
                { c.BizLogType.Purchase_Apportion_Export, 201126 },
                { c.BizLogType.Purchase_InStockMemo, 201127 },
                { c.BizLogType.Purchase_Item_Check, 201128 },
                { c.BizLogType.Purchase_AutoAbandon, 201129 },
                { c.BizLogType.POCToAcc_Add, 201130 },
                { c.BizLogType.POC_VendorSettle_Create, 201131 },
                { c.BizLogType.POC_VendorSettle_Master_Update, 201132 },
                { c.BizLogType.POC_VendorSettle_Item_Add, 201133 },
                { c.BizLogType.POC_VendorSettle_Item_Delete, 201134 },
                { c.BizLogType.POC_VendorSettle_Item_Update, 201135 },
                { c.BizLogType.POC_VendorSettle_Audit, 201136 },
                { c.BizLogType.POC_VendorSettle_CancelAudit, 201137 },
                { c.BizLogType.POC_VendorSettle_Settle, 201138 },
                { c.BizLogType.POC_VendorSettle_CancelSettle, 201139 },
                { c.BizLogType.POC_VendorSettle_Abandon, 201140 },
                { c.BizLogType.POC_VendorSettle_CancelAbandon, 201141 },
                { c.BizLogType.POC_FinanceSettle_Create, 201142 },
                { c.BizLogType.POC_FinanceSettle_Abandon, 201143 },
                { c.BizLogType.POC_FinanceSettle_CancelAbandon, 201144 },
                { c.BizLogType.Purchase_PMRequestMemo, 201145 },
                { c.BizLogType.Purchase_TLRequestMemo, 201146 },
                { c.BizLogType.Finance_Pay_Item_Add, 301110 },
                { c.BizLogType.Finance_Pay_Item_Update, 301111 },
                { c.BizLogType.Finance_Pay_Item_Abandon, 301112 },
                { c.BizLogType.Finance_Pay_Item_CancelAbandon, 301113 },
                { c.BizLogType.Finance_Pay_Item_Pay, 301114 },
                { c.BizLogType.Finance_Pay_Item_CancelPay, 301115 },
                { c.BizLogType.Finance_Pay_Update, 301116 },
                { c.BizLogType.Finance_SOIncome_Add, 301201 },
                { c.BizLogType.Finance_SOIncome_Abandon, 301202 },
                { c.BizLogType.Finance_SOIncome_Confirm, 301203 },
                { c.BizLogType.Finance_SOIncome_UnConfirm, 301204 },
                { c.BizLogType.Finance_SOIncome_UpdateIncomeAmt, 301205 },
                { c.BizLogType.Finance_SOIncome_UpdateInvoiceNo, 301206 },
                { c.BizLogType.Finance_NetPay_AddVerified, 301310 },
                { c.BizLogType.Finance_NetPay_Verify, 301311 },
                { c.BizLogType.Finance_NetPay_Abandon, 301312 },
                { c.BizLogType.Finance_AdvancePay_Check, 301313 },
                { c.BizLogType.FinanceRemitNoOwnerEdit, 301314 },
                { c.BizLogType.FinanceRemitNoOwnerClaimAudit, 301315 },
                { c.BizLogType.FinanceRemitNoOwnerDelete, 301316 },
                { c.BizLogType.Add_NewEggAccounts_Point, 301401 },
                { c.BizLogType.Online_Bulletin_Update, 401001 },
                { c.BizLogType.Online_List_Insert, 401002 },
                { c.BizLogType.Online_List_Delete, 401003 },
                { c.BizLogType.Online_Poll_Insert, 401004 },
                { c.BizLogType.Online_Poll_Update, 401005 },
                { c.BizLogType.Online_Poll_InsertItem, 401006 },
                { c.BizLogType.Online_Poll_UpdateItem, 401007 },
                { c.BizLogType.Online_Poll_DeleteItem, 401008 },
                { c.BizLogType.Online_Poll_Show, 401009 },
                { c.BizLogType.Online_Poll_NotShow, 401010 },
                { c.BizLogType.Online_FeedBack_Update, 401011 },
                { c.BizLogType.Online_ProductQuestion_Reply, 401012 },
                { c.BizLogType.PromotionAdd, 402001 },
                { c.BizLogType.PromotionInvalid, 402002 },
                { c.BizLogType.PromotionValid, 402003 },
                { c.BizLogType.PromotionCodeAdd, 402004 },
                { c.BizLogType.PromotionCodeInvalid, 402005 },
                { c.BizLogType.PromotionCodeValid, 402006 },
                { c.BizLogType.PromotionCodeDistribute, 402007 },
                { c.BizLogType.PromotionCustomerDelete, 402008 },
                { c.BizLogType.PromotionProductAdd, 402009 },
                { c.BizLogType.PromotionProductDelete, 402010 },
                { c.BizLogType.BetAdd, 402011 },
                { c.BizLogType.BetUpdate, 402012 },
                { c.BizLogType.BetOptionAdd, 402013 },
                { c.BizLogType.BetOptionDelete, 402014 },
                { c.BizLogType.BetAnswerSet, 402015 },
                { c.BizLogType.BetOpen, 402016 },
                { c.BizLogType.PromotionEdit, 402017 },
                { c.BizLogType.PromotionLimitAdd, 402018 },
                { c.BizLogType.PromotionLimitEdit, 402019 },
                { c.BizLogType.PromotionLimitDelete, 402020 },
                { c.BizLogType.PromotionCodeDelete, 402021 },
                { c.BizLogType.PromotionCodeEdit, 402022 },
                { c.BizLogType.Auction_Status_Update, 405001 },
                { c.BizLogType.Auction_Detail_Update, 405002 },
                { c.BizLogType.Auction_Detail_Insert, 405003 },
                { c.BizLogType.AuctionComment_Status_Update, 405004 },
                { c.BizLogType.Auction_Trubermaker_Insert, 405005 },
                { c.BizLogType.Auction_Status_Confirm, 405006 },
                { c.BizLogType.Auction_Status_Delete, 405007 },
                { c.BizLogType.Auction_Reset_Status_Update, 405008 },
                { c.BizLogType.Countdown_Insert, 408001 },
                { c.BizLogType.Countdown_Update, 408002 },
                { c.BizLogType.Countdown_Abandon, 408003 },
                { c.BizLogType.Countdown_Interupt, 408004 },
                { c.BizLogType.Countdown_Verify, 408005 },
                { c.BizLogType.Countdown_VerifyPass, 408006 },
                { c.BizLogType.Countdown_VerifyFaild, 408007 },
                { c.BizLogType.Delivery_OK, 409001 },
                { c.BizLogType.Delivery_Abandon, 409002 },
                { c.BizLogType.Delivery_Failure, 409003 },
                { c.BizLogType.Delivery_NoAction, 409004 },
                { c.BizLogType.Delivery_ReAssign, 409005 },
                { c.BizLogType.PO_Vendor_Invoice_Add, 409006 },
                { c.BizLogType.PO_Vendor_Invoice_Update, 409007 },
                { c.BizLogType.PO_Vendor_Invoice_Verify, 409008 },
                { c.BizLogType.PO_Vendor_Invoice_CancelVerify, 409009 },
                { c.BizLogType.PO_Vendor_Invoice_Abandon, 409010 },
                { c.BizLogType.PO_Vendor_Invoice_CancelAbandon, 409011 },
                { c.BizLogType.InvoiceInput_Add, 500000 },
                { c.BizLogType.InvoiceInput_SubmitAudit, 500001 },
                { c.BizLogType.InvoiceInput_CancelAudit, 500002 },
                { c.BizLogType.InvoiceInput_PassAudit, 500003 },
                { c.BizLogType.InvoiceInput_RefuseAudit, 500004 },
                { c.BizLogType.St_Lend_Master_Insert, 501110 },
                { c.BizLogType.St_Lend_Master_Update, 501111 },
                { c.BizLogType.St_Lend_Item_Insert, 501112 },
                { c.BizLogType.St_Lend_Item_Delete, 501113 },
                { c.BizLogType.St_Lend_Item_Update, 501114 },
                { c.BizLogType.St_Lend_Abandon, 501115 },
                { c.BizLogType.St_Lend_CancelAbandon, 501116 },
                { c.BizLogType.St_Lend_Verify, 501117 },
                { c.BizLogType.St_Lend_CancelVerify, 501118 },
                { c.BizLogType.St_Lend_OutStock, 501119 },
                { c.BizLogType.St_Lend_CancelOutStock, 501120 },
                { c.BizLogType.St_Lend_Return_Insert, 501121 },
                { c.BizLogType.St_Lend_Return_Delete, 501122 },
                { c.BizLogType.St_Adjust_Master_Insert, 501210 },
                { c.BizLogType.St_Adjust_Master_Update, 501211 },
                { c.BizLogType.St_Adjust_Item_Insert, 501212 },
                { c.BizLogType.St_Adjust_Item_Delete, 501213 },
                { c.BizLogType.St_Adjust_Item_Update, 501214 },
                { c.BizLogType.St_Adjust_Abandon, 501215 },
                { c.BizLogType.St_Adjust_CancelAbandon, 501216 },
                { c.BizLogType.St_Adjust_Verify, 501217 },
                { c.BizLogType.St_Adjust_CancelVerify, 501218 },
                { c.BizLogType.St_Adjust_OutStock, 501219 },
                { c.BizLogType.St_Adjust_CancelOutStock, 501220 },
                { c.BizLogType.St_Shift_Master_Insert, 501310 },
                { c.BizLogType.St_Shift_Master_Update, 501311 },
                { c.BizLogType.St_Shift_Item_Insert, 501312 },
                { c.BizLogType.St_Shift_Item_Delete, 501313 },
                { c.BizLogType.St_Shift_Item_Update, 501314 },
                { c.BizLogType.St_Shift_Abandon, 501315 },
                { c.BizLogType.St_Shift_CancelAbandon, 501316 },
                { c.BizLogType.St_Shift_Verify, 501317 },
                { c.BizLogType.St_Shift_CancelVerify, 501318 },
                { c.BizLogType.St_Shift_OutStock, 501319 },
                { c.BizLogType.St_Shift_CancelOutStock, 501320 },
                { c.BizLogType.St_Shift_InStock, 501321 },
                { c.BizLogType.St_Shift_CancelInStock, 501322 },
                { c.BizLogType.St_Shift_BatchInsert, 501323 },
                { c.BizLogType.St_Transfer_Master_Insert, 501410 },
                { c.BizLogType.St_Transfer_Master_Update, 501411 },
                { c.BizLogType.St_Transfer_Item_Insert, 501412 },
                { c.BizLogType.St_Transfer_Item_Update, 501414 },
                { c.BizLogType.St_Transfer_Abandon, 501415 },
                { c.BizLogType.St_Transfer_CancelAbandon, 501416 },
                { c.BizLogType.St_Transfer_Verify, 501417 },
                { c.BizLogType.St_Transfer_CancelVerify, 501418 },
                { c.BizLogType.St_Transfer_OutStock, 501419 },
                { c.BizLogType.St_Transfer_CancelOutStock, 501420 },
                { c.BizLogType.St_Virtual_Insert, 501510 },
                { c.BizLogType.St_SOVirtualItemRequest_Add, 501511 },
                { c.BizLogType.St_SOVirtualItemRequest_Save, 501512 },
                { c.BizLogType.St_SOVirtualItemRequest_Abandon, 501513 },
                { c.BizLogType.St_SOVirtualItemRequest_UpdateCSMemo, 501514 },
                { c.BizLogType.St_Category3SetRMAInfo_Update, 501515 },
                { c.BizLogType.St_Inventory_SetPos, 501610 },
                { c.BizLogType.AuditRefund_Update, 600000 },
                { c.BizLogType.Sale_SO_WebSite_Create, 0 },
                { c.BizLogType.Sale_SO_WebSite_Submit, 200 },
                { c.BizLogType.Sale_SO_Create, 600601 },
                { c.BizLogType.Sale_SO_Audit, 600602 },
                { c.BizLogType.Sale_SO_CancelAudit, 600603 },
                { c.BizLogType.Sale_SO_ManagerAudit, 600604 },
                { c.BizLogType.Sale_SO_CustomerAbandon, 600605 },
                { c.BizLogType.Sale_SO_EmployeeAbandon, 600606 },
                { c.BizLogType.Sale_SO_ManagerAbandon, 600607 },
                { c.BizLogType.Sale_SO_CancelAbandon, 600608 },
                { c.BizLogType.Sale_SO_OutStock, 600609 },
                { c.BizLogType.Sale_SO_CancelOutStock, 600610 },
                { c.BizLogType.Sale_SO_PrintInvoice, 600611 },
                { c.BizLogType.Sale_SO_Update, 600612 },
                { c.BizLogType.Sale_SO_FastCashRebate, 600613 },
                { c.BizLogType.Sale_SO_HoldSO, 600614 },
                { c.BizLogType.Sale_SO_UnHoldSO, 600615 },
                { c.BizLogType.Sale_SO_VoideSO, 600616 },
                { c.BizLogType.Sale_SO_UpdateInvoiceNo, 600617 },
                { c.BizLogType.Sale_SO_SplitInvoice, 600618 },
                { c.BizLogType.Sale_SO_CancelSplitInvoice, 600619 },
                { c.BizLogType.Sale_RMA_Create, 600801 },
                { c.BizLogType.Sale_RMA_Abandon, 600802 },
                { c.BizLogType.Sale_RMA_Audit, 600803 },
                { c.BizLogType.Sale_RMA_CancelAudit, 600804 },
                { c.BizLogType.Sale_RMA_Receive, 600805 },
                { c.BizLogType.Sale_RMA_CancelReceive, 600806 },
                { c.BizLogType.Sale_RMA_Handle, 600807 },
                { c.BizLogType.Sale_RMA_CancelHandle, 600808 },
                { c.BizLogType.Sale_RMA_Close, 600809 },
                { c.BizLogType.Sale_RMA_Reopen, 600810 },
                { c.BizLogType.Sale_RO_Create, 600901 },
                { c.BizLogType.Sale_RO_Abandon, 600902 },
                { c.BizLogType.Sale_RO_Audit, 600903 },
                { c.BizLogType.Sale_RO_CancelAudit, 600904 },
                { c.BizLogType.Sale_RO_Return, 600905 },
                { c.BizLogType.Sale_RO_CancelReturn, 600906 },
                { c.BizLogType.Sale_RO_PrintInvoice, 600907 },
                { c.BizLogType.Sale_RMA_Create2, 700801 },
                { c.BizLogType.Sale_RMA_Abandon2, 700802 },
                { c.BizLogType.Sale_RMA_Audit2, 700803 },
                { c.BizLogType.RMA_OutBound_Create, 702001 },
                { c.BizLogType.RMA_OutBound_Update, 702002 },
                { c.BizLogType.RMA_OutBound_OutStock, 702003 },
                { c.BizLogType.RMA_OutBound_CancelOutStock, 702004 },
                { c.BizLogType.RMA_OutBound_DeleteItem, 702005 },
                { c.BizLogType.RMA_OutBound_InsertItem, 702006 },
                { c.BizLogType.RMA_OutBound_Abandon, 702007 },
                { c.BizLogType.RMA_Register_Check, 703001 },
                { c.BizLogType.RMA_Register_Memo, 703002 },
                { c.BizLogType.RMA_Register_Outbound, 703003 },
                { c.BizLogType.RMA_Register_Revert, 703004 },
                { c.BizLogType.RMA_Register_Refund, 703005 },
                { c.BizLogType.RMA_Register_Return, 703006 },
                { c.BizLogType.RMA_Register_Close, 703007 },
                { c.BizLogType.RMA_Register_ToCC, 703008 },
                { c.BizLogType.RMA_Register_ToRMA, 703009 },
                { c.BizLogType.RMA_Register_RevertAudit, 703010 },
                { c.BizLogType.RMA_Register_ResponseInfo, 703011 },
                { c.BizLogType.RMA_Register_ToRegister, 703012 },
                { c.BizLogType.RMA_Register_ToCheck, 703013 },
                { c.BizLogType.RMA_Register_ToASK, 703014 },
                { c.BizLogType.RMA_Register_ToRevert, 703015 },
                { c.BizLogType.RMA_Register_ToReturn, 703016 },
                { c.BizLogType.RMA_Register_ToECC, 703017 },
                { c.BizLogType.RMA_Revert_Create, 704001 },
                { c.BizLogType.RMA_Revert_Update, 704002 },
                { c.BizLogType.RMA_Revert_Abandon, 704003 },
                { c.BizLogType.RMA_Revert_Out, 704004 },
                { c.BizLogType.RMA_Revert_CancelOut, 704005 },
                { c.BizLogType.RMA_Refund_Create, 705001 },
                { c.BizLogType.RMA_Refund_Upate, 705002 },
                { c.BizLogType.RMA_Refund_Abandon, 705003 },
                { c.BizLogType.RMA_Refund_Audit, 705004 },
                { c.BizLogType.RMA_Refund_Refund, 705006 },
                { c.BizLogType.AO_Refund_Refund, 705008 },
                { c.BizLogType.RMA_Refund_CancelRefund, 705007 },
                { c.BizLogType.RMA_Return_Create, 706001 },
                { c.BizLogType.RMA_Return_Update, 706002 },
                { c.BizLogType.RMA_Return_Abandon, 706003 },
                { c.BizLogType.RMA_Return_Return, 706004 },
                { c.BizLogType.RMA_Return_CancelReturn, 706005 },
                { c.BizLogType.RMA_Return_Audit, 706006 },
                { c.BizLogType.RMA_Request_Create, 707001 },
                { c.BizLogType.RMA_Request_Update, 707002 },
                { c.BizLogType.RMA_Request_Receive, 707003 },
                { c.BizLogType.RMA_Request_CancelReceive, 707004 },
                { c.BizLogType.RMA_Request_Abandon, 707005 },
                { c.BizLogType.RMA_Request_Close, 707006 },
                { c.BizLogType.RMA_Request_ReCreate, 707007 },
                { c.BizLogType.RMA_Auto_Request, 707008 },
                { c.BizLogType.RMA_Auto_Refund, 707009 },
                { c.BizLogType.RMA_Auto_Return, 707010 },
                { c.BizLogType.PO_SendMail, 808001 },
                { c.BizLogType.InventoryBackUp, 999998 },
                { c.BizLogType.ZZZZZ, 999999 }
            });

            EnumCodeMapper.AddMap <FreeShippingAmountSettingStatus>(new Dictionary <FreeShippingAmountSettingStatus, string> {
                { FreeShippingAmountSettingStatus.Active, "A" },
                { FreeShippingAmountSettingStatus.DeActive, "D" }
            });
        }
Exemplo n.º 7
0
        public void Start()
        {
            EnumCodeMapper.AddMap <CustomerType>(new Dictionary <CustomerType, int> {
                { CustomerType.Personal, 0 },
                { CustomerType.Enterprise, 1 },
                { CustomerType.Campus, 2 },
                { CustomerType.Media, 3 },
                { CustomerType.Internal, 4 }
            });


            EnumCodeMapper.AddMap <AvtarShowStatus>(new Dictionary <AvtarShowStatus, string>()
            {
                { AvtarShowStatus.NotSet, "S" },
                { AvtarShowStatus.Show, "A" },
                { AvtarShowStatus.NotShow, "D" }
            });
            //兼容数据库中头像状态为S的情况
            EnumCodeMapper.AddExtraCodeMap <AvtarShowStatus>(AvtarShowStatus.NotSet, "0"); //前台注册时为0,其实

            EnumCodeMapper.AddExtraCodeMap <CustomerStatus>(CustomerStatus.InValid, -1);   //前台注册时为0,其实

            EnumCodeMapper.AddMap <OrderCheckStatus>(new Dictionary <OrderCheckStatus, int>()
            {
                { OrderCheckStatus.Invalid, 1 },
                { OrderCheckStatus.Valid, 0 }
            });

            EnumCodeMapper.AddMap <RefundRequestType>(new Dictionary <RefundRequestType, string>()
            {
                { RefundRequestType.SO, "S" },
                { RefundRequestType.Balance, "C" }
            });

            EnumCodeMapper.AddMap <RefundRequestStatus>(new Dictionary <RefundRequestStatus, string>()
            {
                { RefundRequestStatus.A, "A" },
                { RefundRequestStatus.O, "O" },
                { RefundRequestStatus.R, "R" }
            });

            EnumCodeMapper.AddMap <PrepayStatus>(new Dictionary <PrepayStatus, string>()
            {
                { PrepayStatus.Valid, "A" },
                { PrepayStatus.InValid, "D" }
            });

            //EnumCodeMapper.AddMap<CompanyCustomer>(new Dictionary<CompanyCustomer, int>()
            //{
            //    {CompanyCustomer.Newegg,0},
            //    {CompanyCustomer.AstraZeneca,1}
            //});
            EnumCodeMapper.AddMap <RefundAdjustStatus>(new Dictionary <RefundAdjustStatus, int>()
            {
                { RefundAdjustStatus.Abandon, -1 },
                { RefundAdjustStatus.Initial, 0 },
                { RefundAdjustStatus.WaitingAudit, 1 },
                { RefundAdjustStatus.AuditRefuesed, 2 },
                { RefundAdjustStatus.Audited, 3 },
                { RefundAdjustStatus.Refunded, 4 }
            });
            EnumCodeMapper.AddMap <RefundAdjustType>(new Dictionary <RefundAdjustType, int>()
            {
                { RefundAdjustType.ShippingAdjust, 1 },
                { RefundAdjustType.Other, 2 }
            });
        }
Exemplo n.º 8
0
        public void Start()
        {
            EnumCodeMapper.AddMap <AdjustRequestStatus>(new Dictionary <AdjustRequestStatus, int> {
                { AdjustRequestStatus.Origin, 1 },
                { AdjustRequestStatus.Verified, 2 },
                { AdjustRequestStatus.OutStock, 3 },
                { AdjustRequestStatus.Abandon, -1 }
            });

            EnumCodeMapper.AddMap <ConvertRequestStatus>(new Dictionary <ConvertRequestStatus, int> {
                { ConvertRequestStatus.Origin, 1 },
                { ConvertRequestStatus.Verified, 2 },
                { ConvertRequestStatus.OutStock, 3 },
                { ConvertRequestStatus.Abandon, -1 }
            });

            EnumCodeMapper.AddMap <LendRequestStatus>(new Dictionary <LendRequestStatus, int> {
                { LendRequestStatus.Origin, 1 },
                { LendRequestStatus.Verified, 2 },
                { LendRequestStatus.OutStock, 3 },
                { LendRequestStatus.Abandon, -1 },
                { LendRequestStatus.ReturnPartly, 4 },
                { LendRequestStatus.ReturnAll, 5 }
            });

            EnumCodeMapper.AddMap <ShiftRequestStatus>(new Dictionary <ShiftRequestStatus, int> {
                { ShiftRequestStatus.Origin, 1 },
                { ShiftRequestStatus.Verified, 2 },
                { ShiftRequestStatus.OutStock, 3 },
                { ShiftRequestStatus.Abandon, -1 },
                { ShiftRequestStatus.InStock, 4 },
                { ShiftRequestStatus.PartlyInStock, 5 }
            });

            EnumCodeMapper.AddMap <ConvertProductType>(new Dictionary <ConvertProductType, int> {
                { ConvertProductType.Source, 1 },
                { ConvertProductType.Target, 2 }
            });

            EnumCodeMapper.AddMap <VirtualRequestActionType>(new Dictionary <VirtualRequestActionType, string> {
                { VirtualRequestActionType.Run, "R" },
                { VirtualRequestActionType.Close, "C" }
            });

            EnumCodeMapper.AddMap <SpecialShiftRequestType>(new Dictionary <SpecialShiftRequestType, int> {
                { SpecialShiftRequestType.Default, 0 },
                { SpecialShiftRequestType.DelayOutStock, 1 },
                { SpecialShiftRequestType.UrgencyDelayInStock, 2 },
                { SpecialShiftRequestType.NormalDelayInStock, 3 },
                { SpecialShiftRequestType.HandWork, 4 }
            });

            EnumCodeMapper.AddMap <WarehouseType>(new Dictionary <WarehouseType, int> {
                { WarehouseType.Real, 1 },
                { WarehouseType.Virtual, 2 }
            });

            EnumCodeMapper.AddMap <WarehouseOwnerType>(new Dictionary <WarehouseOwnerType, int> {
                { WarehouseOwnerType.Self, 1 },
                { WarehouseOwnerType.ThirdParty, 2 }
            });

            EnumCodeMapper.AddMap <ValidStatus>(new Dictionary <ValidStatus, int> {
                { ValidStatus.Valid, 0 },
                { ValidStatus.InValid, -1 }
            });

            EnumCodeMapper.AddMap <CustomsCodeMode>(new Dictionary <CustomsCodeMode, string> {
                { CustomsCodeMode.DirectImportMode, "2244" },
                { CustomsCodeMode.PudongAirportTradeMode, "2216" },
                { CustomsCodeMode.YangshanTradeMode, "2249" },
                { CustomsCodeMode.WaigaoqiaoTradeMode, "2218" }
            });
        }
Exemplo n.º 9
0
        public void Start()
        {
            #region EIMS
            EnumCodeMapper.AddMap <InvoiceStatus>(new Dictionary <InvoiceStatus, string>
            {
                { InvoiceStatus.AutoClose, "F" },
                { InvoiceStatus.Open, "O" },
                { InvoiceStatus.Lock, "E" }
            });
            #endregion

            #region VendorPortal

            EnumCodeMapper.AddMap <ValidStatus>(new Dictionary <ValidStatus, string> {
                { ValidStatus.Active, "A" },
                { ValidStatus.DeActive, "D" }
            });

            #endregion

            #region CPS

            EnumCodeMapper.AddMap <FinanceStatus>(new Dictionary <FinanceStatus, string> {
                { FinanceStatus.Paid, "P" },
                { FinanceStatus.Settled, "S" },
                { FinanceStatus.Unsettled, "U" },
                { FinanceStatus.UnRequest, "R" },
                { FinanceStatus.Abandon, "V" }
            });

            EnumCodeMapper.AddMap <CPSOrderType>(new Dictionary <CPSOrderType, string> {
                { CPSOrderType.SO, "SO" },
                { CPSOrderType.RMA, "RMA" }
            });

            EnumCodeMapper.AddMap <ToCashStatus>(new Dictionary <ToCashStatus, string> {
                { ToCashStatus.Paid, "P" },
                { ToCashStatus.Requested, "R" },
                { ToCashStatus.Confirmed, "C" }
            });

            EnumCodeMapper.AddMap <AdvertisingType>(new Dictionary <AdvertisingType, string> {
                { AdvertisingType.Custom, "C" },
                { AdvertisingType.IMG, "I" },
                { AdvertisingType.TEXT, "T" }
            });
            EnumCodeMapper.AddMap <AuditStatus>(new Dictionary <AuditStatus, string> {
                { AuditStatus.AuditClearance, "A" },
                { AuditStatus.AuditNoClearance, "D" },
                { AuditStatus.AuditReady, "O" }
            });
            EnumCodeMapper.AddMap <UserType>(new Dictionary <UserType, string> {
                { UserType.Personal, "P" },
                { UserType.Enterprise, "E" }
                //{ UserType.Other, "O" }
            });
            EnumCodeMapper.AddMap <IsActive>(new Dictionary <IsActive, string> {
                { IsActive.DeActive, "0" },
                { IsActive.Active, "1" },
            });
            EnumCodeMapper.AddMap <IsLock>(new Dictionary <IsLock, string> {
                { IsLock.Lock, "L" },
                { IsLock.UnLock, "U" },
            });

            EnumCodeMapper.AddMap <CanProvideInvoice>(new Dictionary <CanProvideInvoice, string> {
                { CanProvideInvoice.Yes, "Y" },
                { CanProvideInvoice.No, "N" }
            });

            #endregion
        }
Exemplo n.º 10
0
        public void Start()
        {
            EnumCodeMapper.AddMap <ECCentral.BizEntity.SO.SODeliveryPromise>(new Dictionary <ECCentral.BizEntity.SO.SODeliveryPromise, string> {
                { ECCentral.BizEntity.SO.SODeliveryPromise.In24H, "24H" },
                { ECCentral.BizEntity.SO.SODeliveryPromise.NoPromise, "" }
            });
            EnumCodeMapper.AddMap <ECCentral.BizEntity.SO.SOPriceStatus>(new Dictionary <ECCentral.BizEntity.SO.SOPriceStatus, string> {
                { ECCentral.BizEntity.SO.SOPriceStatus.Original, "O" },
                { ECCentral.BizEntity.SO.SOPriceStatus.Deactivate, "D" }
            });
            EnumCodeMapper.AddMap <ECCentral.BizEntity.SO.SettlementStatus>(new Dictionary <ECCentral.BizEntity.SO.SettlementStatus, string> {
                { ECCentral.BizEntity.SO.SettlementStatus.PlanFail, "P" },
                { ECCentral.BizEntity.SO.SettlementStatus.Fail, "F" },
                { ECCentral.BizEntity.SO.SettlementStatus.Success, "S" }
            });

            EnumCodeMapper.AddExtraCodeMap <SOStatus>(new Dictionary <SOStatus, object[]> {
                { SOStatus.Abandon, new object[] { -1, -2, -3, -4 } },
                { SOStatus.Origin, new object[] { 0, 2 } }
            });

            EnumCodeMapper.AddExtraCodeMap <SOComplainReplyType>(SOComplainReplyType.Phone, ResSOEnum.SOComplainReplyType_Phone);
            EnumCodeMapper.AddExtraCodeMap <SOComplainReplyType>(SOComplainReplyType.Email, ResSOEnum.SOComplainReplyType_Email);

            EnumCodeMapper.AddMap <ECCentral.BizEntity.SO.SOSplitType>(new Dictionary <ECCentral.BizEntity.SO.SOSplitType, string> {
                { ECCentral.BizEntity.SO.SOSplitType.Normal, "0" },
                { ECCentral.BizEntity.SO.SOSplitType.Force, "1" },
                { ECCentral.BizEntity.SO.SOSplitType.Customer, "2" },
                { ECCentral.BizEntity.SO.SOSplitType.SubSO, "3" }
            });

            EnumCodeMapper.AddMap <ECCentral.BizEntity.SO.SOProductType>(new Dictionary <ECCentral.BizEntity.SO.SOProductType, string> {
                { ECCentral.BizEntity.SO.SOProductType.Product, "0" },
                { ECCentral.BizEntity.SO.SOProductType.Gift, "1" },
                { ECCentral.BizEntity.SO.SOProductType.Award, "2" },
                { ECCentral.BizEntity.SO.SOProductType.Coupon, "3" },
                { ECCentral.BizEntity.SO.SOProductType.ExtendWarranty, "4" },
                { ECCentral.BizEntity.SO.SOProductType.Accessory, "5" },
                { ECCentral.BizEntity.SO.SOProductType.SelfGift, "6" }
            });
            EnumCodeMapper.AddMap <ECCentral.BizEntity.SO.SOProductPriceType>(new Dictionary <ECCentral.BizEntity.SO.SOProductPriceType, string> {
                { ECCentral.BizEntity.SO.SOProductPriceType.Normal, "0" },
                { ECCentral.BizEntity.SO.SOProductPriceType.Member, "1" },
                { ECCentral.BizEntity.SO.SOProductPriceType.WholeSale, "2" }
            });
            EnumCodeMapper.AddMap <ECCentral.BizEntity.IM.ProductPayType>(new Dictionary <ECCentral.BizEntity.IM.ProductPayType, string> {
                { ECCentral.BizEntity.IM.ProductPayType.MoneyOnly, "0" },
                { ECCentral.BizEntity.IM.ProductPayType.All, "1" },
                { ECCentral.BizEntity.IM.ProductPayType.PointOnly, "2" }
            });

            EnumCodeMapper.AddMap <ECCentral.BizEntity.SO.WMSAction>(new Dictionary <ECCentral.BizEntity.SO.WMSAction, string> {
                { ECCentral.BizEntity.SO.WMSAction.Abandon, "V" },
                { ECCentral.BizEntity.SO.WMSAction.AbandonHold, "D" },
                { ECCentral.BizEntity.SO.WMSAction.CancelAuditHold, "C" },
                { ECCentral.BizEntity.SO.WMSAction.Hold, "H" },
                { ECCentral.BizEntity.SO.WMSAction.UnHold, "U" }
            });

            EnumCodeMapper.AddMap <ECCentral.BizEntity.SO.OPCStatus>(new Dictionary <ECCentral.BizEntity.SO.OPCStatus, string> {
                { ECCentral.BizEntity.SO.OPCStatus.Close, "C" },
                { ECCentral.BizEntity.SO.OPCStatus.Error, "E" },
                { ECCentral.BizEntity.SO.OPCStatus.Fail, "F" },
                { ECCentral.BizEntity.SO.OPCStatus.Open, "O" }
            });
            EnumCodeMapper.AddMap <ECCentral.BizEntity.SO.OPCTransStatus>(new Dictionary <ECCentral.BizEntity.SO.OPCTransStatus, string> {
                { ECCentral.BizEntity.SO.OPCTransStatus.Origin, "O" },
                { ECCentral.BizEntity.SO.OPCTransStatus.Error, "E" },
                { ECCentral.BizEntity.SO.OPCTransStatus.Fail, "F" },
                { ECCentral.BizEntity.SO.OPCTransStatus.Success, "S" }
            });
            EnumCodeMapper.AddMap(new Dictionary <ECCentral.BizEntity.SO.ValidStatus, string>
            {
                { ECCentral.BizEntity.SO.ValidStatus.Active, "A" },
                { ECCentral.BizEntity.SO.ValidStatus.DeActive, "D" }
            });


            EnumCodeMapper.AddMap(new Dictionary <ECCentral.BizEntity.SO.SOProductActivityType, string>
            {
                { ECCentral.BizEntity.SO.SOProductActivityType.GroupBuy, "G" },
                { ECCentral.BizEntity.SO.SOProductActivityType.SpecialAccount, "C" },
                { ECCentral.BizEntity.SO.SOProductActivityType.E_Promotion, "E" }
            });
        }
Exemplo n.º 11
0
        public void Start()
        {
            //注册付款单审核状态
            EnumCodeMapper.AddMap <PayableAuditStatus>(new Dictionary <PayableAuditStatus, string>
            {
                { PayableAuditStatus.NotAudit, "O" },
                { PayableAuditStatus.WaitFNAudit, "F" },
                { PayableAuditStatus.Audited, "A" }
            });

            //注册邮局电汇收款单确认状态
            EnumCodeMapper.AddMap <PostIncomeConfirmStatus>(new Dictionary <PostIncomeConfirmStatus, string>
            {
                { PostIncomeConfirmStatus.Audit, "A" },
                { PostIncomeConfirmStatus.Cancel, "C" },
                { PostIncomeConfirmStatus.Related, "R" }
            });

            //注册订单跟进状态
            EnumCodeMapper.AddMap <TrackingInfoStatus>(new Dictionary <TrackingInfoStatus, string>
            {
                { TrackingInfoStatus.Follow, "A" },
                { TrackingInfoStatus.Submit, "S" },
                { TrackingInfoStatus.Confirm, "C" }
            });

            //注册POS支付方式
            EnumCodeMapper.AddMap <POSPayType>(new Dictionary <POSPayType, string>
            {
                { POSPayType.Card, "01" },
                { POSPayType.Cash, "02" },
                { POSPayType.Check, "03" }
            });

            //注册POS自动确认状态
            EnumCodeMapper.AddMap <AutoConfirmStatus>(new Dictionary <AutoConfirmStatus, string>
            {
                { AutoConfirmStatus.Success, "A" },
                { AutoConfirmStatus.Fault, "D" }
            });

            //注册逾期未收款订单责任人状态
            EnumCodeMapper.AddMap <ResponseUserStatus>(new Dictionary <ResponseUserStatus, string>
            {
                { ResponseUserStatus.Active, "A" },
                { ResponseUserStatus.Dective, "D" }
            });

            EnumCodeMapper.AddMap <ECCentral.BizEntity.Invoice.InvoiceType>(new Dictionary <ECCentral.BizEntity.Invoice.InvoiceType, string> {
                { ECCentral.BizEntity.Invoice.InvoiceType.MET, "MET" },
                { ECCentral.BizEntity.Invoice.InvoiceType.SELF, "NEG" },
            });

            EnumCodeMapper.AddMap <ECCentral.BizEntity.Invoice.DeliveryType>(new Dictionary <ECCentral.BizEntity.Invoice.DeliveryType, string> {
                { ECCentral.BizEntity.Invoice.DeliveryType.MET, "MET" },
                { ECCentral.BizEntity.Invoice.DeliveryType.SELF, "NEG" },
            });

            EnumCodeMapper.AddMap <ECCentral.BizEntity.Invoice.StockType>(new Dictionary <ECCentral.BizEntity.Invoice.StockType, string> {
                { ECCentral.BizEntity.Invoice.StockType.MET, "MET" },
                { ECCentral.BizEntity.Invoice.StockType.SELF, "NEG" },
                { ECCentral.BizEntity.Invoice.StockType.NAM, "NAM" }
            });

            //注册付款单审核状态
            EnumCodeMapper.AddMap <SapImportedStatus>(new Dictionary <SapImportedStatus, string>
            {
                { SapImportedStatus.Origin, "A" },
                { SapImportedStatus.Success, "S" },
                { SapImportedStatus.Fault, "E" },
                { SapImportedStatus.Unfinished, "F" }
            });
            EnumCodeMapper.AddMap <APInvoiceItemStatus>(new Dictionary <APInvoiceItemStatus, string>
            {
                { APInvoiceItemStatus.Active, "A" },
                { APInvoiceItemStatus.Deactive, "D" }
            });

            EnumCodeMapper.AddMap <SAPStatus>(new Dictionary <SAPStatus, string>
            {
                { SAPStatus.Active, "A" },
                { SAPStatus.Deactive, "D" }
            });

            //注册以旧换新状态
            EnumCodeMapper.AddMap <OldChangeNewStatus>(new Dictionary <OldChangeNewStatus, string>
            {
                { OldChangeNewStatus.Abandon, "-1" },
                { OldChangeNewStatus.Audited, "2" },
                { OldChangeNewStatus.Close, "4" },
                { OldChangeNewStatus.Origin, "0" },
                { OldChangeNewStatus.Refund, "3" },
                { OldChangeNewStatus.RefuseAudit, "-2" },
                { OldChangeNewStatus.SubmitAudit, "1" }
            });

            //退款结果
            EnumCodeMapper.AddMap <WLTRefundStatus>(new Dictionary <WLTRefundStatus, int>
            {
                { WLTRefundStatus.Success, 1 },
                { WLTRefundStatus.Failure, -1 },
                { WLTRefundStatus.Processing, 3 }
            });

            // 变价单状态
            EnumCodeMapper.AddMap <RequestPriceStatus>(new Dictionary <RequestPriceStatus, int>
            {
                { RequestPriceStatus.Auditting, 0 },
                { RequestPriceStatus.Audited, 1 },
                { RequestPriceStatus.Running, 2 },
                { RequestPriceStatus.Aborted, 3 },
                { RequestPriceStatus.Finished, 4 },
                { RequestPriceStatus.Void, -1 }
            });

            // 变价单变价类型
            EnumCodeMapper.AddMap <RequestPriceType>(new Dictionary <RequestPriceType, int>
            {
                { RequestPriceType.PurchasePrice, 0 },
                { RequestPriceType.SalePrice, 1 }
            });
        }
Exemplo n.º 12
0
        public void Start()
        {
            EnumCodeMapper.AddMap <ECCentral.BizEntity.PO.VendorInvoiceType>(new Dictionary <ECCentral.BizEntity.PO.VendorInvoiceType, string> {
                { ECCentral.BizEntity.PO.VendorInvoiceType.NEG, "NEG" },
                { ECCentral.BizEntity.PO.VendorInvoiceType.MET, "MET" },
                { ECCentral.BizEntity.PO.VendorInvoiceType.GUD, "GUD" }
            });
            EnumCodeMapper.AddMap <ECCentral.BizEntity.PO.VendorShippingType>(new Dictionary <ECCentral.BizEntity.PO.VendorShippingType, string> {
                { ECCentral.BizEntity.PO.VendorShippingType.NEG, "NEG" },
                { ECCentral.BizEntity.PO.VendorShippingType.MET, "MET" }
            });
            EnumCodeMapper.AddMap <ECCentral.BizEntity.PO.VendorStockType>(new Dictionary <ECCentral.BizEntity.PO.VendorStockType, string> {
                { ECCentral.BizEntity.PO.VendorStockType.NEG, "NEG" },
                { ECCentral.BizEntity.PO.VendorStockType.MET, "MET" },
                { ECCentral.BizEntity.PO.VendorStockType.NAM, "NAM" }
            });

            EnumCodeMapper.AddMap <GatherSettleStatus>(new Dictionary <GatherSettleStatus, string> {
                { GatherSettleStatus.ABD, "ABD" },
                { GatherSettleStatus.ORG, "ORG" },
                { GatherSettleStatus.AUD, "AUD" },
                { GatherSettleStatus.SET, "SET" }
            });

            EnumCodeMapper.AddMap <ECCentral.BizEntity.PO.ValidStatus>(new Dictionary <ECCentral.BizEntity.PO.ValidStatus, int> {
                { ECCentral.BizEntity.PO.ValidStatus.D, -1 },
                { ECCentral.BizEntity.PO.ValidStatus.A, 0 }
            });

            EnumCodeMapper.AddMap <ConsignToAccountLogStatus>(new Dictionary <ConsignToAccountLogStatus, string>
            {
                { ConsignToAccountLogStatus.Origin, "A" },
                { ConsignToAccountLogStatus.SystemCreated, "S" },
                { ConsignToAccountLogStatus.ManualCreated, "C" },
                { ConsignToAccountLogStatus.Settled, "F" }
            });
            EnumCodeMapper.AddMap <SettleType>(new Dictionary <SettleType, string>
            {
                { SettleType.O, "O" },
                { SettleType.P, "P" }
            });

            EnumCodeMapper.AddMap <ConsignToAccountType>(new Dictionary <ConsignToAccountType, string>
            {
                { ConsignToAccountType.Adjust, "AD" },
                { ConsignToAccountType.Manual, "RMA" },
                { ConsignToAccountType.RMA, "OR" },
                { ConsignToAccountType.SO, "SO" }
            });
            EnumCodeMapper.AddExtraCodeMap(ConsignToAccountType.Manual, new object[] { "IT" });

            EnumCodeMapper.AddMap <PurchaseOrderETAHalfDayType>(new Dictionary <PurchaseOrderETAHalfDayType, string> {
                { PurchaseOrderETAHalfDayType.AM, "AM" },
                { PurchaseOrderETAHalfDayType.PM, "PM" }
            });

            EnumCodeMapper.AddMap <PurchaseOrderTaxRate>(new Dictionary <PurchaseOrderTaxRate, int> {
                { PurchaseOrderTaxRate.Percent000, 0 },
                { PurchaseOrderTaxRate.Percent004, 4 },
                { PurchaseOrderTaxRate.Percent006, 6 },
                { PurchaseOrderTaxRate.Percent013, 13 },
                { PurchaseOrderTaxRate.Percent017, 17 }
            });
            EnumCodeMapper.AddMap <YNStatus>(new Dictionary <YNStatus, string>
            {
                { YNStatus.Yes, "Y" },
                { YNStatus.NO, "N" }
            });
            EnumCodeMapper.AddMap <VendorCommissionItemType>(new Dictionary <VendorCommissionItemType, string>
            {
                { VendorCommissionItemType.DEF, "DEF" },
                { VendorCommissionItemType.SOC, "SOC" },
                { VendorCommissionItemType.SAC, "SAC" }
            });
            EnumCodeMapper.AddMap <VendorCommissionReferenceType>(new Dictionary <VendorCommissionReferenceType, string>
            {
                { VendorCommissionReferenceType.SO, "SO" },
                { VendorCommissionReferenceType.RMA, "RMA" }
            });

            EnumCodeMapper.AddMap <VendorRank>(new Dictionary <VendorRank, string>
            {
                { VendorRank.A, "A" },
                { VendorRank.B, "B" },
                { VendorRank.C, "C" }
            });

            EnumCodeMapper.AddMap <ConsignSettleRuleStatus>(new Dictionary <ConsignSettleRuleStatus, string>
            {
                { ConsignSettleRuleStatus.Wait_Audit, "O" },
                { ConsignSettleRuleStatus.Stop, "S" },
                { ConsignSettleRuleStatus.Forbid, "F" },
                { ConsignSettleRuleStatus.Enable, "E" },
                { ConsignSettleRuleStatus.Disable, "D" },
                { ConsignSettleRuleStatus.Available, "A" }
            });
            EnumCodeMapper.AddMap <PurchaseOrderBatchInfoStatus>(new Dictionary <PurchaseOrderBatchInfoStatus, string>
            {
                { PurchaseOrderBatchInfoStatus.A, "A" },
                { PurchaseOrderBatchInfoStatus.I, "I" },
                { PurchaseOrderBatchInfoStatus.R, "R" }
            });
        }
Exemplo n.º 13
0
        public void Start()
        {
            EnumCodeMapper.AddMap <UserStatus>(new Dictionary <UserStatus, string> {
                { UserStatus.A, "A" },
                { UserStatus.D, "D" }
            });

            EnumCodeMapper.AddMap <RoleStatus>(new Dictionary <RoleStatus, string> {
                { RoleStatus.Active, "A" },
                { RoleStatus.DeActive, "D" }
            });


            EnumCodeMapper.AddMap <SettleOrderStatus>(new Dictionary <SettleOrderStatus, string> {
                { SettleOrderStatus.CLS, "CLS" },
                { SettleOrderStatus.ORG, "ORG" },
                { SettleOrderStatus.SET, "SET" }
            });
            EnumCodeMapper.AddMap <CommissionType>(new Dictionary <CommissionType, string> {
                { CommissionType.DEF, "DEF" },
                { CommissionType.SAC, "SAC" },
                { CommissionType.SOC, "SOC" }
            });

            EnumCodeMapper.AddMap <ProductRangeType>(new Dictionary <ProductRangeType, string> {
                { ProductRangeType.All, "A" },
                { ProductRangeType.Limit, "I" }
            });

            EnumCodeMapper.AddMap <RelationType>(new Dictionary <RelationType, string> {
                { RelationType.Y, "Y" },
                { RelationType.N, "N" }
            });

            EnumCodeMapper.AddMap <CouponStatus>(new Dictionary <CouponStatus, string> {
                { CouponStatus.Init, "O" },
                { CouponStatus.WaitingAudit, "W" },
                { CouponStatus.Ready, "R" },
                { CouponStatus.Run, "A" },
                { CouponStatus.Void, "D" },
                { CouponStatus.Stoped, "S" },
                { CouponStatus.Finish, "F" }
            });

            EnumCodeMapper.AddMap <CouponDiscountRuleType>(new Dictionary <CouponDiscountRuleType, string> {
                { CouponDiscountRuleType.Discount, "D" },
                { CouponDiscountRuleType.Percentage, "P" }
            });

            EnumCodeMapper.AddMap <CouponsBindConditionType>(new Dictionary <CouponsBindConditionType, string> {
                { CouponsBindConditionType.None, "A" },
                { CouponsBindConditionType.SO, "O" },
                { CouponsBindConditionType.Get, "L" }
            });

            EnumCodeMapper.AddMap <CouponValidPeriodType>(new Dictionary <CouponValidPeriodType, int> {
                { CouponValidPeriodType.All, 0 },
                { CouponValidPeriodType.PublishDayToOneWeek, 1 },
                { CouponValidPeriodType.PublishDayToOneMonth, 2 },
                { CouponValidPeriodType.PublishDayToTwoMonths, 3 },
                { CouponValidPeriodType.PublishDayToThreeMonths, 4 },
                { CouponValidPeriodType.PublishDayToSixMonths, 5 },
                { CouponValidPeriodType.CustomPeriod, 6 }
            });

            EnumCodeMapper.AddMap <SaleGiftType>(new Dictionary <SaleGiftType, string> {
                { SaleGiftType.Single, "S" },
                { SaleGiftType.Multiple, "M" },
                { SaleGiftType.Full, "F" }
                //{ SaleGiftType.Vendor, "V" },
                //{ SaleGiftType.Additional, "F" }
            });
            EnumCodeMapper.AddMap <SaleGiftStatus>(new Dictionary <SaleGiftStatus, string> {
                { SaleGiftStatus.Origin, "O" },
                { SaleGiftStatus.WaitingAudit, "P" },
                { SaleGiftStatus.Ready, "R" },
                { SaleGiftStatus.Run, "A" },
                { SaleGiftStatus.Stoped, "S" },
                { SaleGiftStatus.Finish, "F" },
                { SaleGiftStatus.Void, "D" }
            });
            EnumCodeMapper.AddMap <SaleGiftDiscountBelongType>(new Dictionary <SaleGiftDiscountBelongType, string>
            {
                { SaleGiftDiscountBelongType.BelongGiftItem, "G" },
                { SaleGiftDiscountBelongType.BelongMasterItem, "M" }
            });

            EnumCodeMapper.AddMap <Specified>(new Dictionary <Specified, string>
            {
                { Specified.Y, "Y" },
                { Specified.N, "N" }
            });

            EnumCodeMapper.AddMap <CouponCodeType>(new Dictionary <CouponCodeType, string> {
                { CouponCodeType.Common, "C" },
                { CouponCodeType.ThrowIn, "T" }
            });
            EnumCodeMapper.AddMap <AndOrType>(new Dictionary <AndOrType, string>
            {
                { AndOrType.And, "A" },
                { AndOrType.Not, "N" }
            });

            EnumCodeMapper.AddMap <CouponCodeUsedStatus>(new Dictionary <CouponCodeUsedStatus, string> {
                { CouponCodeUsedStatus.Active, "A" },
                { CouponCodeUsedStatus.Deactive, "D" }
            });

            EnumCodeMapper.AddMap <CustomerType>(new Dictionary <CustomerType, int> {
                { CustomerType.Personal, 0 },
                { CustomerType.Enterprise, 1 },
                { CustomerType.Campus, 2 },
                { CustomerType.Media, 3 },
                { CustomerType.Internal, 4 }
            });

            EnumCodeMapper.AddExtraCodeMap <CustomerStatus>(CustomerStatus.InValid, -1);

            EnumCodeMapper.AddMap <SOPriceStatus>(new Dictionary <SOPriceStatus, string> {
                { SOPriceStatus.Original, "O" },
                { SOPriceStatus.Deactivate, "D" }
            });

            EnumCodeMapper.AddMap <ShippingStockType>(new Dictionary <ShippingStockType, string> {
                { ShippingStockType.MET, "MET" },
                { ShippingStockType.NEG, "NEG" }
            });

            EnumCodeMapper.AddMap <FreeShippingAmountSettingStatus>(new Dictionary <FreeShippingAmountSettingStatus, string> {
                { FreeShippingAmountSettingStatus.Active, "A" },
                { FreeShippingAmountSettingStatus.DeActive, "D" }
            });
        }