Example #1
0
        public void Create_Frames_For_All_Frames_With_The_Same_Position()
        {
            var indexMethod = new IndexMethod();

            indexMethod.TimeTravelFacade = new TimeTravelFacadeBuilder()
                                           .WithGetCurrentFrame(1, new Frame {
                ThreadId = 1
            })
                                           .WithGetCurrentFrame(2, new Frame {
                ThreadId = 2
            })
                                           .Build();

            var positionsResult = new PositionsResult(new[]
            {
                new PositionsRecord(1, new Position(1, 1), true),
                new PositionsRecord(3, new Position(2, 1), false),
                new PositionsRecord(2, new Position(1, 1), false)
            });

            var frames = indexMethod.CreateFramesForUpsert(positionsResult);

            frames[0].ThreadId.Should().Be(1);
            frames[1].ThreadId.Should().Be(2);
        }
        public JsonResult <PositionsResult> Get(string firstInput, string secondInput, bool comprehensive = false)
        {
            var positionsResult = new PositionsResult {
                Positions = new List <Position>()
            };

            var coordinateInput = new CoordinateInput(firstInput, secondInput);

            if (!coordinateInput.IsParsable())
            {
                positionsResult.ParseError = true;
                return(Json(positionsResult));
            }

            // Create possible coordinates from input values:
            var coordinates = CoordinateInputParser.GetCoordinates(coordinateInput, comprehensive: comprehensive);

            // Return an empty result if no coordinates could be made from the user input
            if (coordinates.Count == 0)
            {
                positionsResult.ParseError = true;
                return(Json(positionsResult));
            }

            // Use all supported coordinatesystems if search is comprehensive, only WGS84 otherwise:
            var supportedCoordinateSystems = comprehensive ? CoordinateSystemsSetup.Get() : CoordinateSystemsSetup.Find(84);

            // Try find positions for the coordinates, within supported coordinatesystems and defined limits:
            var positionFinder = new PositionFinder {
                SupportedCoordinateSystems = supportedCoordinateSystems
            };

            positionsResult.Positions     = positionFinder.Find(coordinates);
            positionsResult.Comprehensive = comprehensive || coordinates[0].X.Format.StartsWith("Deg");

            if (positionsResult.Positions.Count > 0 || positionsResult.Comprehensive)
            {
                return(Json(positionsResult));
            }

            // Use all coordinatesystems:
            positionFinder.SupportedCoordinateSystems = CoordinateSystemsSetup.Get();
            positionsResult.Positions = positionFinder.Find(coordinates);

            if (positionsResult.Positions.Count > 0)
            {
                return(Json(positionsResult));
            }

            // Auto-comprehensive - include inverted coordinatevalues:
            coordinates = CoordinateInputParser.GetCoordinates(coordinateInput, comprehensive: true);
            positionFinder.SupportedCoordinateSystems = CoordinateSystemsSetup.Get();
            positionsResult.Positions     = positionFinder.Find(coordinates);
            positionsResult.Comprehensive = true;

            return(Json(positionsResult));
        }
Example #3
0
        public static object POSITIONS(
            [ExcelArgument(Description = "の注文情報を取得する", Name = "商品種別")] string SecurityType,
            [ExcelArgument(Description = "の注文情報を取得する", Name = "銘柄コード")] string Symbol)
        {
            string ret = null;

            string[] Params = { SecurityType, Symbol };
            try
            {
                string ResultMessage = Validate.ValidateMultiple(Params);
                if (!string.IsNullOrEmpty(ResultMessage))
                {
                    return(ResultMessage);
                }

                Tuple <DateTime, string> tpl;
                var tplKey = SecurityType;
                if (_positionsCache.TryGetValue(tplKey, out tpl))
                {
                    if ((DateTime.Now - tpl.Item1).TotalSeconds < 1)
                    {
                        ret = tpl.Item2;
                    }
                }
                if (String.IsNullOrEmpty(ret))
                {
                    ret = middleware.GetPositions(SecurityType, Symbol);
                    _positionsCache[tplKey] = Tuple.Create(DateTime.Now, ret);
                }

                object array;
                array = PositionsResult.PositionCheck(ret);
                if (array == null)
                {
                    // 検証用でAPI実行結果がエラーではない場合
                    return(0);
                }

                return(XlCall.Excel(XlCall.xlUDF, "Resize", array));
            }
            catch (Exception exception)
            {
                if (exception.InnerException == null)
                {
                    return(exception.Message);
                }
                else
                {
                    return(exception.InnerException.Message);
                }
            }
        }
Example #4
0
        public void Identify_The_Current_Thread()
        {
            // arrange
            var records = new[]
            {
                new PositionsRecord(1, new Position(0, 0), false),
                new PositionsRecord(2, new Position(1, 0), true),
                new PositionsRecord(3, new Position(2, 0), false),
                new PositionsRecord(4, new Position(3, 0), false)
            };
            var result = new PositionsResult(records);

            // act
            var thread = result.CurrentThreadResult;

            // assert
            thread.ThreadId.Should().Be(2);
        }
Example #5
0
        public void Be_Iterable()
        {
            // arrange
            var records = new[]
            {
                new PositionsRecord(1, new Position(0, 0), false),
                new PositionsRecord(2, new Position(1, 0), true),
                new PositionsRecord(3, new Position(2, 0), false),
                new PositionsRecord(4, new Position(3, 0), false)
            };
            var result = new PositionsResult(records);

            // act
            // assert
            result.Should().HaveCount(4);
            IEnumerable e = result;

            e.GetEnumerator().Should().NotBeNull();
        }
 /// <summary>
 ///     Withes the positions.
 /// </summary>
 /// <param name="result">The result.</param>
 /// <returns>TimeTravelFacadeBuilder.</returns>
 public TimeTravelFacadeBuilder WithPositions(PositionsResult result)
 {
     Mock.Setup(facade => facade.Positions()).Returns(result);
     return(this);
 }