Exemple #1
0
 public ItemService(IUOW uow_, IRequestResult rs, IMapper mapper_, IItemSchedule scedule_)
 {
     UOW     = uow_;
     mapper  = mapper_;
     RS      = rs;
     scedule = scedule_;
 }
 public ILogger LogIfNot(IRequestResult result, LogLevel level = LogLevel.Info)
 {
     return this.Fluently(() => {
         if (!result.Success)
             Log(level, result.Message);
     });
 }
Exemple #3
0
        public async virtual Task <IRequestResult> Work()
        {
            // Examine the total set of processable units, pending + failure handler set.
            // Select the message based on the nature of the subscriptions quality attributes
            // For now, do the simple thing
            IsWorking = true;
            bool ok = true;

            try {
                if (!HasWork().Success)
                {
                    if (BundlePrototype.QualityConstraints.EndureQuietude.HasValue)
                    {
                        await Task.Delay((int)BundlePrototype.QualityConstraints.EndureQuietude.Value);
                    }
                }
                else
                {
                    var candidate = QueryFailureHandlers();
                    IRequestResult <IProcessableUnit> result = await DispatchMessage(candidate ?? NextUnit());

                    if (result.Containee.IsNotNull())
                    {
                        var conclusion = WorkPolicy.Analyze(result);
                        var handler    = PolicyAnalysisHandler;
                        var action     = PolicyHandlers.FirstOrDefault(h => h.Item1(conclusion));
                        action.IsNotNull(() => action.Item2(result.Containee, handler));
                    }
                }
            }
            finally {
                IsWorking = false;
            }
            return(Result(ok));
        }
 public IWorkPolicyConclusion Analyze(IRequestResult<IProcessableUnit> result)
 {
     var conclusion = new WorkPolicyConclusion();
     conclusion.Completed = result.Success;
     if (!conclusion.Completed)
         ExamineFurther(conclusion, result);
     return conclusion;
 }
Exemple #5
0
 public async Task <TResult> ParseAsync <TResult>(IRequestResult result)
 {
     using (var stream = await result.ReadAsStreamAsync()) {
         var serializer = KnownTypes?.Length > 0
                                 ? new DataContractJsonSerializer(typeof(TResult), KnownTypes)
                                 : new DataContractJsonSerializer(typeof(TResult));
         return((TResult)serializer.ReadObject(stream));
     }
 }
Exemple #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="result"></param>
        /// <returns></returns>
        public static bool IsFailed(this IRequestResult result)
        {
            if (null == result)
            {
                throw new ArgumentNullException(nameof(result));
            }

            return(result.Exceptions.Any());
        }
 public ILogger LogIfNot(IRequestResult result, LogLevel level = LogLevel.Info)
 {
     return(this.Fluently(() => {
         if (!result.Success)
         {
             Log(level, result.Message);
         }
     }));
 }
Exemple #8
0
        public IWorkPolicyConclusion Analyze(IRequestResult <IProcessableUnit> result)
        {
            var conclusion = new WorkPolicyConclusion();

            conclusion.Completed = result.Success;
            if (!conclusion.Completed)
            {
                ExamineFurther(conclusion, result);
            }
            return(conclusion);
        }
Exemple #9
0
        public static IRequestResult ExecuteWithResult(this object src, Action f, Action <Exception> onException = null)
        {
            IRequestResult result = RequestResult.Create();

            try {
                f();
            }
            catch (Exception ex) {
                onException.IsNotNull(() => onException(ex));
                result.Success = false;
            }
            return(result);
        }
 private void ExamineFurther(WorkPolicyConclusion conclusion, IRequestResult<IProcessableUnit> result)
 {
     var unit = result.Containee;
     var quality = unit.Subscription.QualityConstraints;
     if (quality.IsNotNull()) {
         var msg = result.Containee.Message;
         // If makes sense, allow retry
         conclusion.Retry = quality.GuaranteeDelivery && (msg.Retries < quality.MaxRetry);
         msg.Retries++;
         // If need delivery, but cannot retry, go to blocked status
         if (!conclusion.Retry && quality.GuaranteeDelivery) {
             conclusion.Block = true;
             Logger.LogInfo("Blocking subscription: " + unit.ToString());
         }
         conclusion.PassToFailureHandling = !conclusion.Retry && !conclusion.Block;
     }
 }
        public IRequestResult Next()
        {
            IRequestResult <IMessage> result = LiveMessageSource.Retrieve;

            if (result.Success)               // we have a message
            {
                IMessage message = result.Containee;
                // See if any active tasks can accept it; or create a new one if we can
                ISubscription subs = FindApplicableSubscription(message);
                subs
                .IsNull()
                .IfTrue(() => Logger.LogWarning("No subscription for message: " + message.ToString()))
                .IfFalse(() => AssignMessageToHandler(subs, message));
            }
            return(new RequestResult {
                Success = result.Success
            });
        }
Exemple #12
0
        public static void PrintAllTreesCount(int radius)
        {
            IRequestResult r = UO.WaitTargetTile(3348, 339, 4, Graphic.Invariant);

            UO.UseType(0x0F9E);
            //IClientTarget target = UIManager.Target();

            StaticTarget target = ((StaticTarget)r.GetType().GetField("Target").GetValue(r));


            {
                string name = null;
                if (target.Graphic != 0 && target.Graphic < DataFiles.Tiledata.Count)
                {
                    name = DataFiles.Tiledata.GetArt(target.Graphic).Name;
                }

                string format = "Tile X={0} Y={1} Z={2} Graphic=0x{3:X4}";
                if (name != null && name.Length > 0)
                {
                    format += " Name={4}";
                }

                UO.Print(format, target.X, target.Y, target.Z, target.Graphic, name);
            }
            // UO.Print(((StaticTarget)r.GetType().GetField("Target").GetValue(r))+ "" + " / " + Graphic.Invariant);

            {
                string name = null;
                if (target.Graphic != 0 && target.Graphic < DataFiles.Tiledata.Count)
                {
                    name = DataFiles.Tiledata.GetArt(target.Graphic).Name;
                }

                string format = "Tile X={0} Y={1} Z={2} Graphic=0x{3:X4}";
                if (name != null && name.Length > 0)
                {
                    format += " Name={4}";
                }

                Notepad.WriteLine(format, target.X, target.Y, target.Z, target.Graphic, name);
                Notepad.WriteLine();
            }
        }
Exemple #13
0
        private void ExamineFurther(WorkPolicyConclusion conclusion, IRequestResult <IProcessableUnit> result)
        {
            var unit    = result.Containee;
            var quality = unit.Subscription.QualityConstraints;

            if (quality.IsNotNull())
            {
                var msg = result.Containee.Message;
                // If makes sense, allow retry
                conclusion.Retry = quality.GuaranteeDelivery && (msg.Retries < quality.MaxRetry);
                msg.Retries++;
                // If need delivery, but cannot retry, go to blocked status
                if (!conclusion.Retry && quality.GuaranteeDelivery)
                {
                    conclusion.Block = true;
                    Logger.LogInfo("Blocking subscription: " + unit.ToString());
                }
                conclusion.PassToFailureHandling = !conclusion.Retry && !conclusion.Block;
            }
        }
Exemple #14
0
        public void TameCharacter(UOCharacter character, int maxTries, bool keepDisttance)//, Robot r)
        {
            Game.CurrentGame.CurrentPlayer.SwitchWarmode();

            Robot r = new Robot();

            r.UseTryGoOnly     = true;
            r.SearchSuqareSize = 20;

            UOItem currentStaff = EnsuredTamingStaff;
            int    tries        = 0;

            Game.PrintMessage(String.Format("{0}, {1}, {2}, {3}, {4}", character.Exist, character.RequestStatus(500), character.Hits, character.Distance, UO.Dead));

            while (character.Exist && character.RequestStatus(500) && character.Hits > 0 && character.Distance < 6 && !UO.Dead)
            {
                UO.DeleteJournal();

                bool end  = false;
                bool kill = false;

                if (character.Distance > 2 && keepDisttance)
                {
                    r.GoTo(new UOPositionBase(character.X, character.Y, 0), 2, 2);
                    Game.Wait(500);
                }
                UO.Say("Baf");
                Game.Wait();

                UO.UseSkill("Hiding");
                Game.Wait();
                IRequestResult result = UO.WaitTargetObject(character.Serial);
                currentStaff.Use();
                //Game.Wait(500);
                SkillValue tamingValue = SkillsHelper.GetSkillValue("AnimalTaming");
                UOItem     robe        = World.Player.Layers[Layer.OuterTorso];
                Game.PrintMessage("RV: " + tamingValue.RealValue + " / " + robe.Exist);

                using (JournalEventWaiter jew = new JournalEventWaiter(true,
                                                                       "You can't see the target",
                                                                       "Ochoceni se nezdarilo",
                                                                       "Your taming failed",
                                                                       "byl tamnut",
                                                                       "not tamable",
                                                                       "You are not able to tame",
                                                                       "Jsi moc daleko",
                                                                       "Jeste nemuzes pouzit hulku",
                                                                       "toto zvire nelze ochocit",
                                                                       "Toto zvire nedokazes ochocit",
                                                                       "You are not able to tame this animal"

                                                                       ))
                {
                    if (jew.Wait(15000))
                    {
                        if (Journal.Contains(true, "Ochoceni se nezdarilo"))
                        {
                            Game.PrintMessage("Try - Ochoceni se nezdarilo");
                        }
                        else if (Journal.Contains(true, "Your taming failed"))
                        {
                            Game.PrintMessage("Try - Your taming failed");
                        }
                        else if (Journal.Contains(true, "Jeste nemuzes pouzit hulku"))
                        {
                            Game.PrintMessage("Try - Jeste nemuzes pouzit hulku");
                            Game.Wait(6000);
                        }
                        else if (Journal.Contains(true, "Jsi moc daleko"))
                        {
                            if (keepDisttance)
                            {
                                bool go = r.GoTo(new UOPositionBase(character.X, character.Y, 0), 1, 10);
                                if (!go)
                                {
                                    end = true;
                                }
                                Game.Wait();
                                Game.PrintMessage("Try - Jsi moc daleko: " + go);
                            }
                        }
                        else if (Journal.Contains(true, "You can't see the target"))
                        {
                            UO.WaitTargetCancel();
                            Game.Wait();
                            UO.Press(System.Windows.Forms.Keys.Escape);
                            Game.Wait();
                            Game.CurrentGame.CurrentPlayer.SwitchWarmode();
                            Game.Wait();
                            bool go = r.GoTo(new UOPositionBase(character.X, character.Y, 0), 1, 10);
                            if (!go)
                            {
                                end = true;
                            }
                            Game.Wait();

                            Game.PrintMessage("Try - You can't see the target go: " + go);
                        }
                        else if (Journal.Contains(true, "byl tamnut"))// && currentStaff.Color == TamingStaff.Color)
                        {
                            Game.PrintMessage("End - byl tamnut");
                            end = true;
                        }
                        else if (Journal.Contains(true, "not tamable") || Journal.Contains(true, "toto zvire nelze ochocit"))
                        {
                            character.Click();
                            Game.Wait(500);
                            character.RequestStatus(500);

                            bool isTrofejAnimal = false;// TrofejKlamaci.Contains(character.Model);

                            foreach (Graphic g in TrofejKlamaci)
                            {
                                if (g == character.Model)
                                {
                                    isTrofejAnimal = true;
                                }
                            }


                            if (isTrofejAnimal && character.Notoriety != Notoriety.Innocent && character.Notoriety != Notoriety.Invulnerable && character.Notoriety != Notoriety.Guild)//krysa/hind/bear/goat/snake atd)TODO
                            {
                                kill = true;
                                //zabit / riznout / vylotit
                                Game.PrintMessage("Kill - not tamable " + character.Model);
                            }
                            else
                            {
                                Game.PrintMessage("End - not tamable");
                                end = true;
                            }
                        }
                        else if (Journal.Contains(true, "Toto zvire nedokazes ochocit") || Journal.Contains(true, "You are not able to tame this animal"))
                        {
                            if (World.Player.Backpack.AllItems.FindType(0x1F03).Exist)
                            {
                                World.Player.Backpack.AllItems.FindType(0x1F03).Use();
                                Game.Wait(500);
                            }
                            else if (World.Player.Backpack.AllItems.FindType(0x1F01).Exist)
                            {
                                World.Player.Backpack.AllItems.FindType(0x1F01).Use();
                                Game.Wait(500);
                            }

                            if (tries > 1)
                            {
                                Game.PrintMessage("End - Nelze ochocit " + character.Serial);
                                end = true;
                            }

                            Game.Wait(3500);
                        }
                        else
                        {
                            Game.Wait(1000);
                        }
                    }
                    else
                    {
                        if (Game.CurrentGame.WorldSave())
                        {
                            Game.Wait(60000);
                            Game.PrintMessage("Try - WordSave" + character.Serial);
                        }
                        else
                        {
                            if (tries > 1)
                            {
                                Game.PrintMessage("End - JEW timeout " + character.Serial);
                                end = true;
                            }
                        }
                    }

                    if (tries > maxTries)// && currentStaff.Color == TrainTamingStaff.Color)
                    {
                        end = true;
                    }

                    if (tamingValue.RealValue < 1000 && maxTries < 100)
                    {
                        bool switchToTrain  = false;
                        bool switchToTaming = false;
                        if (tries == 0)
                        {
                            if ((Journal.Contains(true, "nenauc") || Journal.Contains(true, "You Cannot learn anything more")) && robe.Exist)
                            {
                                robe.Move(1, World.Player.Backpack);
                                Game.Wait();
                                switchToTrain = true;
                            }

                            if (!Journal.Contains(true, "nenauc"))
                            {
                                switchToTrain = true;
                            }
                        }
                        else if (tries == 1)
                        {
                            if (Journal.Contains(true, "nenauc") || Journal.Contains(true, "You Cannot learn anything more"))
                            {
                                switchToTaming = true;

                                Game.PrintMessage("robe.Exist:" + robe.Exist);

                                if (robe.Exist)
                                {
                                    robe.Use();
                                    Game.Wait();
                                }
                            }
                        }

                        if (switchToTrain)
                        {
                            if (World.Player.Backpack.AllItems.FindType(TrainTamingStaff.Graphic, TrainTamingStaff.Color).Exist)
                            {
                                currentStaff = World.Player.Backpack.AllItems.FindType(TrainTamingStaff.Graphic, TrainTamingStaff.Color);
                            }
                            else if (World.Player.Layers.FindType(TrainTamingStaff.Graphic, TrainTamingStaff.Color).Exist)
                            {
                                currentStaff = World.Player.Backpack.AllItems.FindType(TrainTamingStaff.Graphic, TrainTamingStaff.Color);
                            }

                            Game.Wait();
                        }


                        if (switchToTaming)
                        {
                            currentStaff = EnsuredTamingStaff;
                            Game.Wait();
                        }
                    }
                    if (tries > 2)
                    {
                        if (Journal.Contains(true, "nenauc") || currentStaff.Color == TamingStaffCharged.Color && !World.Player.Layers[Layer.OuterTorso].Exist)
                        {
                            if (World.Player.Backpack.AllItems.FindType(0x1F03).Exist)
                            {
                                World.Player.Backpack.AllItems.FindType(0x1F03).Use();
                                Game.Wait();
                            }
                            else if (World.Player.Backpack.AllItems.FindType(0x1F01).Exist)
                            {
                                World.Player.Backpack.AllItems.FindType(0x1F01).Use();
                                Game.Wait(500);
                            }
                        }
                    }

                    if (kill)
                    {
                        this.KillCharacter(character);
                    }

                    if (end)
                    {
                        Game.PrintMessage("While - end: " + tries);
                        //   doneList.Remove(character.Serial);
                        break;
                    }
                }
                tries++;
                Game.PrintMessage("While - cyklus pokus: " + tries);
            }

            foreach (UOItem item in World.Ground)
            {
                if (item.Distance < 5)
                {
                    bool isKlamak = false;
                    foreach (Graphic g in Taming2.ShrinkKlamaci)
                    {
                        if (item.Graphic == g)
                        {
                            isKlamak = true;
                        }
                    }

                    if (Array.IndexOf(ItemLibrary.ShrinkKlamaci.GraphicArray, item.Graphic) > -1 || Array.IndexOf(ShrinkKlamaci, item.Graphic) > -1 || isKlamak)
                    {
                        item.Move(1, (ushort)(World.Player.X + 1), (ushort)(World.Player.Y + 1), item.Z);
                        Game.Wait(150);
                        item.Move(1, World.Player.Backpack, 30, 30);
                        Game.Wait(150);
                    }
                }
            }

            Game.PrintMessage("While - END");
            if (World.Player.Backpack.AllItems.FindType(0x1F03).Exist)
            {
                World.Player.Backpack.AllItems.FindType(0x1F03).Use();
                Game.Wait(250);
            }
            else if (World.Player.Backpack.AllItems.FindType(0x1F01).Exist)
            {
                World.Player.Backpack.AllItems.FindType(0x1F01).Use();
                Game.Wait(250);
            }
        }
Exemple #15
0
 static UIManager()
 {
     FailedResult = new WaitQuery(null);
     ((WaitQuery)FailedResult).Finish(RequestState.Failed);
 }
Exemple #16
0
 public async Task <TSuccessResult> ParseSuccessResultAsync(HttpStatusCode statusCode, IRequestResult requestResult)
 {
     if (ParseSuccessResultAsyncHandler != null)
     {
         return(await ParseSuccessResultAsyncHandler(statusCode, requestResult));
     }
     else
     {
         return(default(TSuccessResult));
     }
 }
Exemple #17
0
 public async Task <TFailureResult> ParseFailureResultAsync(HttpStatusCode statusCode, IRequestResult requestResult)
 {
     if (ConfigureParameterAsyncHandler != null)
     {
         return(await ParseFailureResultAsyncHandler(statusCode, requestResult));
     }
     else
     {
         throw new RestRequestFailureException(statusCode, await requestResult.ReadAsStringAsync());
     }
 }
 protected override bool IsParsableForFailure(HttpStatusCode statusCode, IRequestResult requestResult)
 {
     return(false);
 }
Exemple #19
0
 public async Task <bool> IsSuccessResultAsync(HttpStatusCode statusCode, bool isSuccessStatusCode, IRequestResult requestResult)
 {
     if (IsSuccessResultAsyncHandler != null)
     {
         return(await IsSuccessResultAsyncHandler(statusCode, isSuccessStatusCode, requestResult));
     }
     else
     {
         return(isSuccessStatusCode);
     }
 }
 protected virtual bool IsParsableForSuccess(HttpStatusCode statusCode, IRequestResult requestResult)
 {
     return(true);
 }
        public virtual async Task <TSuccessResult> ParseSuccessResultAsync(HttpStatusCode statusCode, IRequestResult requestResult)
        {
            if (IsParsableForSuccess(statusCode, requestResult))
            {
                var parser = CreateParser(true);
                if (parser != null)
                {
                    var result = await parser.ParseAsync <TSuccessResult>(requestResult);

                    return(await PostProcessSuccessResultAsync(result, statusCode, requestResult));
                }
            }

            return(default(TSuccessResult));
        }
 public virtual Task <bool> IsSuccessResultAsync(HttpStatusCode statusCode, bool isSuccessStatusCode, IRequestResult requestResult)
 {
     return(Task.FromResult(isSuccessStatusCode));
 }
        public virtual async Task <TFailureResult> ParseFailureResultAsync(HttpStatusCode statusCode, IRequestResult requestResult)
        {
            if (IsParsableForFailure(statusCode, requestResult))
            {
                var parser = CreateParser(false);
                if (parser != null)
                {
                    var result = await parser.ParseAsync <TFailureResult>(requestResult);

                    return(await PostProcessFailureResultAsync(result, statusCode, requestResult));
                }
            }
            throw new RestRequestFailureException(statusCode, await requestResult.ReadAsStringAsync());
        }
Exemple #24
0
 static UIManager()
 {
     FailedResult = new WaitQuery(null);
     ((WaitQuery)FailedResult).Finish(RequestState.Failed);
 }
 protected virtual Task <TFailureResult> PostProcessFailureResultAsync(TFailureResult result, HttpStatusCode httpStatusCode, IRequestResult requestResult)
 {
     return(Task.FromResult(result));
 }
 public ItemTypeService(IUOW uow_, IRequestResult rs, IMapper mapper_)
 {
     UOW    = uow_;
     mapper = mapper_;
     RS     = rs;
 }
Exemple #27
0
 protected override Task <WabisabiAccessToken> PostProcessSuccessResultAsync(WabisabiAccessToken result, HttpStatusCode httpStatusCode, IRequestResult requestResult)
 {
     result.ExpiresAt = DateTimeOffset.Now.AddSeconds(result.ExpiresIn);
     return(Task.FromResult(result));
 }
Exemple #28
0
 public ActionResult ActionResult(IRequestResult result) =>
 result switch
 {
Exemple #29
0
        public async Task Run(WebSocketReceiveResult result, site.WebSocket webSocket, Jttp jttp)
        {
            //throw new NotImplementedException();
            var ass = Assembly.GetExecutingAssembly();

            //处理特殊交互
            //if (jttp.Header.Type == "Help") {
            //    var reqs = ass.GetTypes().Where(req => req.IsAssignableFrom(typeof(JttpRequest)));
            //    using (dpz.Jsons.Jttp res = new dpz.Jsons.Jttp()) {
            //        res.Header.Ver = "1.0";
            //        res.Header.Type = jttp.Header.Type;
            //        res.Header.Time = "" + dpz.Time.Now.ToTimeStamp();
            //        res.Header.Status = "1";

            //        byte[] bs = System.Text.Encoding.UTF8.GetBytes(jttp.ToJson());
            //        await webSocket.Socket.SendAsync(new ArraySegment<byte>(bs, 0, bs.Length), result.MessageType, result.EndOfMessage, CancellationToken.None);

            //        var objs = new List<dpz.Dynamic>();
            //        res.Data.Requests = objs;
            //        foreach (var req in reqs) {
            //            dynamic obj = new dpz.Dynamic();
            //            obj.Name = req.Name;
            //            objs.Add(obj);
            //        }
            //    }
            //    return;
            //}

            string[]    tps     = jttp.Header.Type.Split('.');
            JttpRequest request = null;

            if (tps.Length <= 1)
            {
                await SendError(result, webSocket, $"不支持的交互类型'{jttp.Header.Type}'"); return;
            }

            //switch (tps[0]) {
            //    case "Socket": request = new Requests.Socket(); break;
            //    case "Session": request = new Requests.Session(); break;
            //    default: await SendError(result, webSocket, $"不支持的交互类型'{jttp.Header.Type}'"); return;
            //}
            var fullName = "Kernel.Wss.Requests." + tps[0];
            var requests = ass.GetTypes();

            for (int i = 0; i < requests.Length; i++)
            {
                var req = requests[i];
                if (req.FullName == fullName)
                {
                    //新建反射对象
                    request = ass.CreateInstance(fullName) as JttpRequest;
                    request.Init(result, webSocket, jttp);

                    var methods = req.GetMethods();
                    for (int j = 0; j < methods.Length; j++)
                    {
                        var method = methods[j];
                        if (method.Name == tps[1])
                        {
                            //处理前置事件
                            IRequestResult resExecuting = request.OnExecuting();
                            if (resExecuting != null)
                            {
                                resExecuting.SetResult(request.JResponse);
                            }
                            else
                            {
                                IRequestResult res = method.Invoke(request, null) as IRequestResult;
                                res.SetResult(request.JResponse);

                                //处理后置事件
                                IRequestResult resExecuted = request.OnExecuted();
                                if (resExecuted != null)
                                {
                                    resExecuted.SetResult(request.JResponse);
                                }
                            }

                            await request.Render();

                            //await task;
                            return;
                        }
                    }

                    await SendError(result, webSocket, $"不支持的交互子对象'{jttp.Header.Type}'");

                    return;
                }
            }

            await SendError(result, webSocket, $"不支持的交互对象'{tps[0]}'");
        }
Exemple #30
0
 public Decorator(IRequestResult result, HttpRequest request, object model)
     : base(request, model)
 {
     this.RequestResult = result;
 }
 protected sealed override bool IsParsableForSuccess(HttpStatusCode statusCode, IRequestResult requestResult)
 {
     return(false);
 }
 public DecoratorResultWithCors(IRequestResult jsonResult, HttpRequest request, object model, string corsSettings)
     : base(jsonResult, request, model)
 {
     this.RequestResult.AddHeader("Access-Control-Allow-Origin", corsSettings);
 }