public override Resolver ScanBarcode(Resolver resolver)
    {
        try
        {
            resolver.IsCSClient = true;
            resolver = TheResolverMgr.Resolve(resolver);

            //KSS 客户化,只有手持扫描枪需要B/S打印监控
            //if ((resolver.ModuleType == BusinessConstants.TRANSFORMER_MODULE_TYPE_SHIP || resolver.ModuleType == BusinessConstants.TRANSFORMER_MODULE_TYPE_SHIPORDER)
            //    && resolver.NeedPrintAsn && resolver.PrintUrl != null && resolver.PrintUrl.Trim() != string.Empty)
            //{
            //    //resolver.PrintUrl = null;
            //    InProcessLocation inProcessLocation = TheInProcessLocationMgr.LoadInProcessLocation(resolver.Code);
            //    inProcessLocation.IsPrinted = true;//to be refactored
            //    TheInProcessLocationMgr.UpdateInProcessLocation(inProcessLocation);
            //}
            return resolver;
        }
        catch (BusinessErrorException ex)
        {
            string exMessage = RenderingLanguage(ex.Message, resolver.UserCode, ex.MessageParams);
            throw new SoapException(exMessage, SoapException.ServerFaultCode, string.Empty);
        }
        catch (Exception ex)
        {
            throw new SoapException(ex.Message, SoapException.ServerFaultCode, string.Empty);
        }
    }

 protected override void SetDetail(Resolver resolver)
 {
     LocationLotDetail locationLotDetail = locationLotDetailMgrE.CheckLoadHuLocationLotDetail(resolver.Input, resolver.UserCode);
     TransformerDetail transformerDetail = TransformerHelper.ConvertLocationLotDetailToTransformerDetail(locationLotDetail, false);
     resolver.AddTransformerDetail(transformerDetail);
     resolver.Command = BusinessConstants.CS_BIND_VALUE_TRANSFORMERDETAIL;
 }

        //private static readonly string openDnsResolver2 = "208.67.220.220";
        /// <summary>
        /// Resolves the IP address of the specified hostname.
        /// </summary>
        /// <param name="hostname">The hostname.</param>
        /// <returns>IPAddress instance.</returns>
        public IPAddress ResolveHostnameIP(string hostname)
        {
            if (!NetworkInterface.GetIsNetworkAvailable())
            {
                throw new ApplicationException(Text.Error_NoNetwork);
            }

            Resolver resolver = new Resolver(openDnsResolver1);
            IPHostEntry host = resolver.GetHostEntry(hostname);

            if (host == null || host.AddressList == null || host.AddressList.Length <= 0)
            {
                throw new ApplicationException(string.Format(Text.Error_CantResolveHostnameIP, hostname));
            }

            IPAddress result = host
                .AddressList
                .FirstOrDefault(ip => ip.AddressFamily == AddressFamily.InterNetwork);

            if (result == null)
            {
                throw new ApplicationException(string.Format(Text.Error_CantResolveHostnameIP, hostname));
            }

            log.DebugFormat(Text.Debug_ResolvedHostname, hostname, result.ToString());

            return result;
        }

        public void FillResolverByASN(Resolver resolver)
        {
            User user = userMgrE.CheckAndLoadUser(resolver.UserCode);
            InProcessLocation inProcessLocation = inProcessLocationMgrE.CheckAndLoadInProcessLocation(resolver.Input);

            //if (!user.HasPermission(inProcessLocation.PartyFrom.Code) ||
            //    !user.HasPermission(inProcessLocation.PartyTo.Code))
            //{
            //    throw new BusinessErrorException("Common.Business.Error.NoPermission");
            //}

            #region CopyProperty from ASN
            resolver.Code = inProcessLocation.IpNo;
            resolver.Status = inProcessLocation.Status;
            //resolver.IsDetailContainHu = inProcessLocation.IsDetailContainHu;
            resolver.IsScanHu = inProcessLocation.IsReceiptScanHu;
            if (inProcessLocation.InProcessLocationDetails != null && inProcessLocation.InProcessLocationDetails.Count > 0)
            {
                OrderHead orderHead =  inProcessLocation.InProcessLocationDetails[0].OrderLocationTransaction.OrderDetail.OrderHead;
                resolver.AntiResolveHu = orderHead.AntiResolveHu;
                resolver.FulfillUnitCount = orderHead.FulfillUnitCount;
                resolver.AllowExceed = orderHead.AllowExceed;
            }
            resolver.PickBy = inProcessLocation.IsDetailContainHu ? BusinessConstants.CODE_MASTER_PICKBY_HU : BusinessConstants.CODE_MASTER_PICKBY_ITEM;
            //resolver.PickBy = inProcessLocation.IsReceiptScanHu ? BusinessConstants.CODE_MASTER_PICKBY_HU : BusinessConstants.CODE_MASTER_PICKBY_ITEM;
            resolver.OrderType = inProcessLocation.OrderType;

            //resolver.AntiResolveHu = 
            #endregion
        }

 protected override void SetDetail(Resolver resolver)
 {
     List<string> flowTypes = new List<string>();
     flowTypes.Add(BusinessConstants.CODE_MASTER_ORDER_TYPE_VALUE_PRODUCTION);
     bool isHaslocationLotDetail = locationLotDetailMgrE.CheckHuLocationExist(resolver.Input);
     if (!isHaslocationLotDetail)
     {
         throw new BusinessErrorException("Hu.Error.NoInventory", resolver.Input);
     }
     Hu hu = huMgrE.CheckAndLoadHu(resolver.Input);
     FlowView flowView = null;
     //如果是扫描Bin,根据Hu和Bin匹配出flow
     if (resolver.CodePrefix == null || resolver.CodePrefix.Trim() == string.Empty)
     {
         //确定flow和flowView
         flowView = flowMgrE.CheckAndLoadFlowView(null, resolver.UserCode, string.Empty, null, hu, flowTypes);
         setBaseMgrE.FillResolverByFlow(resolver, flowView.Flow);
     }
     //如果已经确定了Flow
     else
     {
         //根据Flow和Hu匹配出flowView
         flowView = flowMgrE.CheckAndLoadFlowView(resolver.Code, null, null, null, hu, flowTypes);
     }
     setDetailMgrE.MatchHuByFlowView(resolver, flowView, hu);
 }

 protected override void ExecuteSubmit(Resolver resolver)
 {
     User user = userMgr.LoadUser(resolver.UserCode, false, true);
     IList<CycleCountDetail> cycleCountDetailList = this.ConvertResolverToCycleCountDetail(resolver);
     if (resolver.CodePrefix == BusinessConstants.CODE_PREFIX_CYCCNT)
     {
         cycleCountMgr.RecordCycleCountDetail(resolver.Code, cycleCountDetailList, user);
         resolver.Result = languageMgr.TranslateMessage("CycCnt.Process.Successfully", resolver.UserCode);
         resolver.Transformers = null;
         resolver.Command = BusinessConstants.CS_BIND_VALUE_TRANSFORMER;
         resolver.BinCode = null;
         resolver.LocationCode = null;
     }
     //else if (resolver.LocationCode != null && resolver.LocationCode.Trim() != string.Empty)
     //{
     //    if (resolver.BinCode != null && resolver.BinCode.Trim() != string.Empty)
     //    {
     //        StorageBin bin = storageBinMgr.CheckAndLoadStorageBin(resolver.BinCode);
     //        cycleCountMgr.CreateCycleCount(bin, cycleCountDetailList, user);
     //    }
     //    else
     //    {
     //        Location location = locationMgr.CheckAndLoadLocation(resolver.LocationCode);
     //        cycleCountMgr.CreateCycleCount(location, cycleCountDetailList, user);
     //    }
     //}
     else
     {
         throw new BusinessErrorException("Common.Business.Error.ScanFlowOrStorageBinFirst");
     }
 }

        protected void ResolveInput(string input, bool bind)
        {
            CacheResolver.Input = input;
            CacheResolver = TheResolverMgr.Resolve(this.CacheResolver);

            if (bind) Bind();
        }

 public void Process(Resolver resolver)
 {
     if (!dicBarcodeHead.ContainsKey(resolver.BarcodeHead))
     {
         throw new BusinessErrorException("Common.Business.Error.BarCodeInvalid");
     }
     switch (dicBarcodeHead[resolver.BarcodeHead])
     {
         case 1:
             SetBaseInfo(resolver);
             GetDetail(resolver);
             break;
         case 2:
             Execute(resolver);
             break;
         case 3:
             GetReceiptNotes(resolver);
             break;
         case 4:
             SetBaseInfo(resolver);
             break;
         default:
             resolver.Input = resolver.Input;
             SetDetail(resolver);//Hu,match or add
             break;
     }
 }

        public void CreateRepack(Resolver resolver)
        {
            IList<RepackDetail> repackDetailList = executeMgr.ConvertTransformerListToRepackDetail(resolver.Transformers);
            if (repackDetailList.Count == 0)
            {
                throw new BusinessErrorException("MasterData.Inventory.Repack.Error.RepackDetailEmpty");
            }
            Repack repack = repackMgr.CreateRepack(repackDetailList, userMgr.LoadUser(resolver.UserCode, false, true));
            resolver.Code = repack.RepackNo;
            resolver.Transformers = null;
            resolver.Command = BusinessConstants.CS_BIND_VALUE_TRANSFORMERDETAIL;
            resolver.Result = languageMgr.TranslateMessage("MasterData.Inventory.Repack.Successfully", resolver.UserCode);

            #region 打印
            if (resolver.IsCSClient)
            {
                IList<Hu> huList = new List<Hu>();
                repack = repackMgr.LoadRepack(resolver.Code, true);
                foreach (RepackDetail repackDet in repack.RepackDetails)
                {
                    if (repackDet.IOType == BusinessConstants.IO_TYPE_OUT && repackDet.LocationLotDetail.Hu != null
                        && repackDet.LocationLotDetail.Hu.PrintCount == 0)
                    {
                        huList.Add(repackDet.LocationLotDetail.Hu);
                    }
                }
                resolver.PrintUrl = PrintHu(huList,resolver.UserCode);
            }
            #endregion
        }

 /// <summary>
 /// 只有发货扫描条码才支持不扫物流路线,扫描库格移库
 /// </summary>
 /// <param name="resolver"></param>
 protected override void SetDetail(Resolver resolver)
 {
     List<string> flowTypes = new List<string>();
     flowTypes.Add(BusinessConstants.CODE_MASTER_ORDER_TYPE_VALUE_TRANSFER);
     Hu hu = huMgrE.CheckAndLoadHu(resolver.Input);
     if (this.locationMgrE.IsHuOcuppyByPickList(resolver.Input))
     {
         throw new BusinessErrorException("Order.Error.PickUp.HuOcuppied", resolver.Input);
     }
     FlowView flowView = null;
     if (resolver.CodePrefix != null && resolver.CodePrefix.Trim() != string.Empty)
     {
         flowView = flowMgrE.CheckAndLoadFlowView(resolver.Code, null, null, null, hu, flowTypes);
     }
     else
     {
         if (resolver.BinCode == string.Empty)
         {
             throw new BusinessErrorException("Common.Business.Error.ScanFlowOrStorageBinFirst");
         }
         else
         {
             flowView = flowMgrE.CheckAndLoadFlowView(null, resolver.UserCode, hu.Location, resolver.LocationToCode, hu, flowTypes);
             setBaseMgrE.FillResolverByFlow(resolver, flowView.Flow);
         }
     }
     setDetailMgrE.MatchHuByFlowView(resolver, flowView, hu);
 }

 public void PickList(Resolver resolver)
 {
     PickList pickList = pickListMgrE.CheckAndLoadPickList(resolver.Code);
     pickList.PickListDetails = new List<PickListDetail>();
     if (resolver.Transformers != null)
     {
         foreach (Transformer transformer in resolver.Transformers)
         {
             PickListDetail pickListDetail = pickListDetailMgrE.LoadPickListDetail(transformer.Id, true);
             if (transformer != null)
             {
                 foreach (TransformerDetail transformerDetail in transformer.TransformerDetails)
                 {
                     if (transformerDetail != null && transformerDetail.HuId != null && transformerDetail.HuId != string.Empty
                         && transformerDetail.CurrentQty != 0)
                     {
                         PickListResult pickListResult = new PickListResult();
                         //pickListResult.LocationLotDetail = locationLotDetailMgrE.LoadLocationLotDetail(transformerDetail.LocationLotDetId);
                         pickListResult.LocationLotDetail = locationLotDetailMgrE.CheckLoadHuLocationLotDetail(transformerDetail.HuId);
                         pickListResult.PickListDetail = pickListDetail;
                         pickListResult.Qty = transformerDetail.CurrentQty * pickListDetail.OrderLocationTransaction.UnitQty;
                         pickListDetail.AddPickListResult(pickListResult);
                     }
                 }
             }
             pickList.AddPickListDetail(pickListDetail);
         }
     }
     pickListMgrE.DoPick(pickList, resolver.UserCode);
     resolver.Result = languageMgrE.TranslateMessage("MasterData.PickList.Pick.Successfully", resolver.UserCode, resolver.Code);
     resolver.Transformers = null;
     resolver.Command = BusinessConstants.CS_BIND_VALUE_TRANSFORMER;
 }

 public override void Resolve(Resolver resolver)
 {
     paramBindings = new List<Binding>(generator.ParamKeys.Count);
     foreach (var key in generator.ParamKeys) {
         paramBindings.Add(resolver.RequestBinding(key, generator.ProviderMethod.FullName));
     }
 }

 protected override void SetBaseInfo(Resolver resolver)
 {
     if (resolver.CodePrefix == BusinessConstants.CODE_PREFIX_INSPECTION)
     {
         InspectOrder inspectOrder = inspectOrderMgrE.CheckAndLoadInspectOrder(resolver.Input);
         if (inspectOrder.Status != BusinessConstants.CODE_MASTER_STATUS_VALUE_CREATE)
         {
             throw new BusinessErrorException("InspectOrder.Error.StatusIsNotValid", resolver.Input, inspectOrder.Status);
         }
         resolver.Code = inspectOrder.InspectNo;
         resolver.IsScanHu = inspectOrder.IsDetailHasHu;
         resolver.Status = inspectOrder.Status;
         if (resolver.IsScanHu)
         {
             resolver.PickBy = BusinessConstants.CODE_MASTER_PICKBY_HU;
         }
         else
         {
             resolver.PickBy = BusinessConstants.CODE_MASTER_PICKBY_ITEM;
         }
     }
     else
     {
         throw new BusinessErrorException("Common.Business.Error.BarCodeInvalid");
     }
 }

 protected override void GetDetail(Resolver resolver)
 {
     InspectOrder inspectOrder = inspectOrderMgrE.LoadInspectOrder(resolver.Code, true);
     resolver.Transformers = TransformerHelper.ConvertInspectDetailToTransformer(inspectOrder.InspectOrderDetails);
     resolver.Command = BusinessConstants.CS_BIND_VALUE_TRANSFORMER;
     resolver.Result = languageMgrE.TranslateMessage("MasterData.Inventory.CurrentInspectOrder", resolver.UserCode, resolver.Code);
 }

        static DNSManager()
        {
            try
            {
                IPEndPoint[] osDNSServers = Resolver.GetDnsServers();
                if (osDNSServers != null && osDNSServers.Length > 0)
                {
                    logger.Debug("Initialising DNS resolver with operating system DNS server entries.");
                    m_resolver = new Resolver(osDNSServers);
                }
                else
                {
                    logger.Debug("Initialising DNS resolver with OpenDNS server entries.");
                    m_resolver = new Resolver(Resolver.DefaultDnsServers.ToArray());
                }
                //m_resolver.Recursion = true;
                //m_resolver.UseCache = false;

                for (int index = 0; index < NUMBER_LOOKUP_THREADS; index++)
                {
                    Thread lookupThread = new Thread(new ThreadStart(ProcessLookups));
                    lookupThread.Name = LOOKUP_THREAD_NAME + "-" + index.ToString();
                    lookupThread.Start();
                }
            }
            catch (Exception excp)
            {
                logger.Error("Exception DNSManager (static ctor). " + excp);
            }
        }

        public StopSpider(IPAddress providerDNS, IPAddress censorRedirect, string provider, string country, string reporter)
        {
            // initiate spiderlist

            this.providerDNS = providerDNS;
            this.censorRedirect = censorRedirect;
            this.provider = provider;
            this.country = country;
            this.reporter = reporter;
            this.openDnsResolver = new Resolver(Resolver.DefaultDnsServers[0]);

            // add an initial list in randomized order, this will also prevent adding already known urls!
            SortedList<int, string> rlist = new SortedList<int, string>();
            TextReader inputurls = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("shortlist.txt"));
            string url; Random r = new Random();
            while ((url = inputurls.ReadLine()) != null)
            {
                rlist.Add(r.Next(), url);
            }

            foreach (string uri in rlist.Values)
            {
                spiderlist.Add(new SpiderInfo(uri, 0));
                spidercheck.Add(uri, true);
            }
        }

        private void WriteToDisk(IExpression expression, Resolver resolver)
        {
            var name = "Output.exe";

            var assemblyName = new AssemblyName(name);

            var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
                assemblyName,
                AssemblyBuilderAccess.RunAndSave
            );

            var moduleBuilder = assemblyBuilder.DefineDynamicModule(name);

            var programClass = moduleBuilder.DefineType("Program", TypeAttributes.Public);

            var mainMethod = programClass.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.Static, null, new[] { typeof(string[]) });

            var il = mainMethod.GetILGenerator();

            new Compiler(il, resolver).Compile(expression);

            programClass.CreateType();

            assemblyBuilder.SetEntryPoint(programClass.GetMethod("Main"));
            assemblyBuilder.Save(name);
        }

        public AGSCharacter(string id, Resolver resolver, IOutfit outfit) : base(id, resolver)
        {            
            _hasRoom = AddComponent<IHasRoom>();            
            _animationContainer = AddComponent<IAnimationContainer>();            
            _inObjectTree = AddComponent<IInObjectTree>();            
            _collider = AddComponent<ICollider>();            
            _visibleComponent = AddComponent<IVisibleComponent>();            
            _enabledComponent = AddComponent<IEnabledComponent>();            
            _customProperties = AddComponent<ICustomPropertiesComponent>();            
            _drawableInfo = AddComponent<IDrawableInfo>();            
            _hotspotComponent = AddComponent<IHotspotComponent>();            
            _shaderComponent = AddComponent<IShaderComponent>();            
            _transformComponent = AddComponent<ITranslateComponent>();            
            _imageComponent = AddComponent<IImageComponent>();            
            _scaleComponent = AddComponent<IScaleComponent>();            
            _rotateComponent = AddComponent<IRotateComponent>();            
            _pixelPerfectComponent = AddComponent<IPixelPerfectComponent>();            
            _faceDirectionBehavior = AddComponent<IFaceDirectionBehavior>();            
            _hasOutfit = AddComponent<IHasOutfit>();            
            _hasInventory = AddComponent<IHasInventory>();            
            _followBehavior = AddComponent<IFollowBehavior>();
			beforeInitComponents(resolver, outfit);            
			InitComponents();
            afterInitComponents(resolver, outfit);            
        }

        public AGSCheckBox(string id, Resolver resolver) : base(id, resolver)
        {            
            _uIEvents = AddComponent<IUIEvents>();            
            _skinComponent = AddComponent<ISkinComponent>();            
            _hasRoom = AddComponent<IHasRoom>();            
            _animationContainer = AddComponent<IAnimationContainer>();            
            _inObjectTree = AddComponent<IInObjectTree>();            
            _collider = AddComponent<ICollider>();            
            _visibleComponent = AddComponent<IVisibleComponent>();            
            _enabledComponent = AddComponent<IEnabledComponent>();            
            _customProperties = AddComponent<ICustomPropertiesComponent>();            
            _drawableInfo = AddComponent<IDrawableInfo>();            
            _hotspotComponent = AddComponent<IHotspotComponent>();            
            _shaderComponent = AddComponent<IShaderComponent>();            
            _translateComponent = AddComponent<ITranslateComponent>();            
            _imageComponent = AddComponent<IImageComponent>();            
            _scaleComponent = AddComponent<IScaleComponent>();            
            _rotateComponent = AddComponent<IRotateComponent>();            
            _pixelPerfectComponent = AddComponent<IPixelPerfectComponent>();            
            _textComponent = AddComponent<ITextComponent>();            
            _checkboxComponent = AddComponent<ICheckboxComponent>();
			beforeInitComponents(resolver);            
			InitComponents();
            afterInitComponents(resolver);            
        }

		public CodeAssistanceContextProvider(Scope scope, string source)
		{
			_scope = scope;
			_completionParser = new CompletionParser(_errorReporter, source);
			_resolver = new Resolver(_errorReporter, _scope);
		    _normalizer = new Normalizer();
		}