public SmartSearchResponse Search(SmartSearchRequest request)
        {
            SmartSearchResponse toRet = new();

            try
            {
                QueryContainer mgmtQuery     = new QueryContainer();
                QueryContainer propertyQuery = new QueryContainer();

                //Building market/state query
                if (request.Market != null)
                {
                    if (!String.IsNullOrWhiteSpace(request.Market.market))
                    {
                        QueryContainer marketQuery
                            = Query <Mgmt>
                              .Match(m => m
                                     .Field(f => f.market.Suffix("keyword"))
                                     .Query(request.Market.market));

                        mgmtQuery     &= marketQuery;
                        propertyQuery &= marketQuery;
                    }

                    if (!String.IsNullOrWhiteSpace(request.Market.state))
                    {
                        QueryContainer stateQuery
                            = Query <Mgmt>
                              .Match(m => m
                                     .Field(f => f.state.Suffix("keyword"))
                                     .Query(request.Market.state));

                        mgmtQuery     &= stateQuery;
                        propertyQuery &= stateQuery;
                    }
                }

                //Building main search term query
                if (!String.IsNullOrWhiteSpace(request.SearchTerm))
                {
                    //for mgmt = only name
                    QueryContainer nameQuery
                        = Query <Mgmt>
                          .Match(m => m
                                 .Field(f => f.name)
                                 .Query(request.SearchTerm)
                                 .Operator(Operator.And)
                                 .Analyzer("my_analyzer")
                                 );


                    mgmtQuery &= nameQuery;

                    //for property = combination of all string fields
                    QueryContainer formerNameQuery
                        = Query <Property>
                          .Match(m => m
                                 .Field(f => f.formerName)
                                 .Query(request.SearchTerm)
                                 .Operator(Operator.And)
                                 .Analyzer("my_analyzer"));

                    QueryContainer streetAddessQuery
                        = Query <Property>
                          .Match(m => m
                                 .Field(f => f.streetAddress)
                                 .Query(request.SearchTerm)
                                 .Operator(Operator.And)
                                 .Analyzer("my_analyzer"));

                    QueryContainer cityQuery
                        = Query <Property>
                          .Match(m => m
                                 .Field(f => f.city)
                                 .Query(request.SearchTerm)
                                 .Operator(Operator.And)
                                 .Analyzer("my_analyzer"));

                    QueryContainer propertySearchQuery = nameQuery || formerNameQuery || streetAddessQuery || cityQuery;

                    propertyQuery &= propertySearchQuery;
                }

                //Searching for Mgmt
                SearchRequest searchMgmtRequest = new("mgmt");
                searchMgmtRequest.Query = mgmtQuery;
                searchMgmtRequest.Size  = request.Limit;

                var searchMgmtResponse = Client.Search <Mgmt>(searchMgmtRequest);

                toRet.Mgmts     = new List <Mgmt>(searchMgmtResponse.Documents);
                toRet.MgmtTotal = searchMgmtResponse.Total;

                //Searching for Properties
                SearchRequest searchProperyRequest = new("property");
                searchProperyRequest.Query = propertyQuery;
                searchProperyRequest.Size  = request.Limit;

                var searchProperyResponse = Client.Search <Property>(searchProperyRequest);

                toRet.Properties      = new List <Property>(searchProperyResponse.Documents);
                toRet.PropertiesTotal = searchProperyResponse.Total;

                toRet.Success = true;
            }
            catch (Exception ex)
            {
                toRet.Success      = false;
                toRet.ErrorMessage = ex.Message; //TODO: something more meaningful for user
                //TODO: log error message
            }
            return(toRet);
        }
 public SmartSearchResponse Get(SmartSearchRequest searchRequest)
 {
     return(_searchManager.Search(searchRequest));
 }