Ejemplo n.º 1
0
        /// <summary>
        ///     Extracts a compound criterion
        /// </summary>
        /// <param name="args">The arguments.</param>
        /// <param name="start">The start.</param>
        /// <param name="lhs">The LHS.</param>
        /// <returns>SearchCriterionDto.</returns>
        /// <exception cref="Exception">Aasdfj;asldkfmn</exception>
        private SearchCriterionDto ExtractCompound(string[] args, int start, SearchCriterionDto lhs)
        {
            if (args == null || !args.Any() || start > args.Length)
            {
                return(null);
            }
            var op   = args[start];
            var crit = new SearchCriterionDto();
            var list = new List <SearchCriterionDto>();

            if (op == "AND")
            {
                crit.Type = "and";
            }
            else if (op == "OR")
            {
                crit.Type = "or";
            }
            else
            {
                throw new Exception("Aasdfj;asldkfmn");
            }
            list.Add(lhs);
            list.Add(ExtractWhere(args, start + 1));
            crit.SubCriteria = list.ToArray();
            return(crit);
        }
Ejemplo n.º 2
0
        /// <summary>
        ///     Converts the specified search criterion dto.
        /// </summary>
        /// <param name="searchCriterionDto">The search criterion dto.</param>
        /// <returns>ICriterion.</returns>
        /// <exception cref="ArgumentException">Input has to have at least 3 arguments</exception>
        /// <exception cref="ArgumentOutOfRangeException"></exception>
        /// <exception cref="Exception">change this</exception>
        public ICriterion Convert(SearchCriterionDto searchCriterionDto)
        {
            var terminal = (TerminalSearchCriterionDto)searchCriterionDto;
            var args     = terminal.Args;

            if (args.Length < 3)
            {
                throw new ArgumentException("Input has to have at least 3 arguments");
            }
            var reg = Register.Lookup(args[0]);

            if (reg == null)
            {
                throw new ArgumentOutOfRangeException();
            }
            switch (args[1])
            {
            case "-eq":
                return(new RegisterEqualsCriterion(reg, Conv.ToUInt64(args[2]).ToHexString()));

            case "-between":
                var low = Conv.ToUInt64(args[2]);
                var hi  = Conv.ToUInt64(args[3]);    // todo: check before
                return(new RegisterBetweenCriterion(reg, low.ToHexString(), hi.ToHexString()));

            default:
                throw new Exception("change this");
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        ///     Searches frames for the request criteria
        /// </summary>
        /// <param name="projectName">Name of the project.</param>
        /// <param name="searchCriterionDto">The search criterion dto.</param>
        /// <returns>IEnumerable&lt;Frame&gt;.</returns>
        internal IEnumerable <Frame> SearchFrames(string projectName, SearchCriterionDto searchCriterionDto)
        {
            var searchCriteria = ConversionFacade.Convert(searchCriterionDto);
            var results        = FrameAccess.Search(projectName, searchCriteria);

            return(results);
        }
Ejemplo n.º 4
0
        /// <summary>
        ///     Extracts a compound criterion
        /// </summary>
        /// <param name="args">The arguments.</param>
        /// <param name="start">The start.</param>
        /// <param name="lhs">The LHS.</param>
        /// <returns>SearchCriterionDto.</returns>
        /// <exception cref="Exception">Aasdfj;asldkfmn</exception>
        private SearchCriterionDto ExtractCompound(string[] args, int start, SearchCriterionDto lhs)
        {
            if (args == null || !args.Any() || start > args.Length)
            {
                return(null);
            }
            var op   = args[start];
            var crit = new SearchCriterionDto();
            var list = new List <SearchCriterionDto>();

            if (op == "AND")
            {
                crit.Type = "and";
            }
            else if (op == "OR")
            {
                crit.Type = "or";
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(op), $"Found boolean operation {op}, which is not a valid operation");
            }
            list.Add(lhs);
            list.Add(ExtractWhere(args, start + 1));
            crit.SubCriteria = list.ToArray();
            return(crit);
        }
        /// <summary>
        ///     Converts the specified search dto.
        /// </summary>
        /// <param name="searchDto">The search dto.</param>
        /// <returns>ICriterion.</returns>
        /// <exception cref="Exception">aslkasldknasdklnas change me!</exception>
        public ICriterion Convert(SearchCriterionDto searchDto)
        {
            var first = Converters.FirstOrDefault(c => c.CanConvert(searchDto));

            if (first == null)
            {
                throw new Exception("aslkasldknasdklnas change me!");
            }

            return(first.Convert(searchDto));
        }
        /// <summary>
        ///     Visits the specified search criterion dto.
        /// </summary>
        /// <param name="searchCriterionDto">The search criterion dto.</param>
        /// <returns>System.Object.</returns>
        public object Visit(SearchCriterionDto searchCriterionDto)
        {
            if (searchCriterionDto is TerminalSearchCriterionDto terminal)
            {
                return(Visit(terminal));
            }
            var o = new JObject {
                { "Type", searchCriterionDto.Type }
            };
            var childObjects = searchCriterionDto.SubCriteria.Select(c => c.Accept(this)).Cast <JObject>().ToArray();
            var arr          = new JArray(childObjects);

            o.Add("SubCriteria", arr);
            return(o);
        }
Ejemplo n.º 7
0
        /// <summary>
        ///     Searches the frames.
        /// </summary>
        /// <param name="converted">The converted.</param>
        /// <returns>IEnumerable&lt;Frame&gt;.</returns>
        public IEnumerable <Frame> SearchFrames(SearchCriterionDto converted)
        {
            var ub = new UriBuilder(Settings.ServerUrl)
            {
                Path = $"api/search/frame"
            };
            var res = HttpFacade.PostJsonAsync(ub.Uri, converted, new HttpHeaders
            {
                ["X-Project-Name"] = Settings.ProjectName
            });
            var json      = res.Result.Content.ReadAsStringAsync().Result; // todo: 500's
            var returnVal = JsonConvert.DeserializeObject <IEnumerable <Frame> >(json);

            return(returnVal);
        }
Ejemplo n.º 8
0
        /// <summary>
        ///     Converts the specified search plan.
        /// </summary>
        /// <param name="searchRequest">The search plan.</param>
        /// <returns>SearchCriterionDto.</returns>
        /// <inheritdoc />
        public SearchCriterionDto Convert(ISearchRequest searchRequest)
        {
            var subs = searchRequest.SearchFilters.Select(ExtractCriterion).ToArray();

            if (subs.Length == 1)
            {
                return(subs[0]);
            }
            var crit = new SearchCriterionDto
            {
                Type        = "and",
                SubCriteria = subs
            };

            return(crit);
        }
Ejemplo n.º 9
0
        public IHttpActionResult Post([FromProjectNameHeader] string projectName, [FromUri] string index,
                                      [FromBody] SearchCriterionDto searchCriterionDto) // todo: add paging headers
        {
            object results = null;

            switch (index.ToLower())
            {
            case "frame":
                results = SearchFrames(projectName, searchCriterionDto);     // todo: add the others
                break;

            default:
                throw new IndexOutOfRangeException($"Uncrecognized index: {index}");
            }

            return(Ok(results));
        }
 /// <summary>
 ///    Converts the search request to JSON
 /// </summary>
 /// <param name="searchRequest">The search request.</param>
 /// <returns>System.String.</returns>
 public string ConvertToJson(SearchCriterionDto searchRequest)
 {
     return(ConvertToJObject(searchRequest).ToString(Formatting.Indented));
 }
        /// <summary>
        ///     Converts to j object.
        /// </summary>
        /// <param name="searchRequest">The search request.</param>
        /// <returns>JObject.</returns>
        public JObject ConvertToJObject(SearchCriterionDto searchRequest)
        {
            var o = (JObject)Visit(searchRequest);

            return(o);
        }
Ejemplo n.º 12
0
 /// <summary>
 ///     Determines whether this instance can convert the specified search criterion dto.
 /// </summary>
 /// <param name="searchCriterionDto">The search criterion dto.</param>
 /// <returns><c>true</c> if this instance can convert the specified search criterion dto; otherwise, <c>false</c>.</returns>
 public bool CanConvert(SearchCriterionDto searchCriterionDto)
 {
     return(searchCriterionDto is TerminalSearchCriterionDto && Regex.IsMatch(searchCriterionDto?.Type ?? "",
                                                                              "register", RegexOptions.IgnoreCase));
 }