public static ServiceProvidersSearchVm GetServiceProvidersSearchVm(ServiceProvidersSearchVm searchVm)
{
if (!ValidatePageNumber(searchVm.PageNumber))
{
return(null);
}
searchVm.ValidationResult = GetLookupLocationValidationVm(searchVm.SearchBar);
if (!searchVm.ValidationResult.IsValid)
{
return(searchVm);
}
searchVm.Criteria = searchVm.ValidationResult.Criteria;
searchVm.SearchBar = GetSearchBarVm(searchVm);
ServiceProviderSearchModel searchModel = searchVm.ToServiceProviderSearchModel();
searchModel = SearchBc.Instance.SearchServiceProviders(searchModel);
searchVm.PageSize = searchModel.PageSize;
searchVm.TotalCount = searchModel.Result.TotalCount;
searchVm.Paging = searchVm.MapToPagingVm();
searchVm.Refine = searchVm.MapToServiceProviderRefineVm();
searchVm.Result = searchModel.Result.Results.MapToServiceProviderBlockVmList();
PopulateFeaturedServices(searchVm);
searchVm.Breadcrumbs = GetBreadcrumbs(searchVm);
searchVm.LeadForm = GetLeadFormVm(searchVm);
searchVm.DisplayProperties = new SearchDisplayProperties();
searchVm.Seo = SeoHelper.GetSeo(searchVm);
return(searchVm);
}
private static NearbySearchResult GetNearbySearchResult(SearchVm searchVm)
{
NearbySearchResult result = null;
if (searchVm.PageType.ToSearchType() != SearchType.ProductsAndServices)
{
CommunitiesSearchVm communitiesSearchVm = searchVm as CommunitiesSearchVm;
if (communitiesSearchVm != null)
{
CommunityNearbySearchModel searchModel = communitiesSearchVm.ToCommunityNearbySearchModel();
searchModel = SearchBc.Instance.SearchNearbyCommunities(searchModel);
result = searchModel.Result;
}
}
else
{
ServiceProvidersSearchVm serviceProvidersSearchVm = searchVm as ServiceProvidersSearchVm;
if (serviceProvidersSearchVm != null)
{
NearbySearchModel searchModel2 = serviceProvidersSearchVm.ToNearbySearchModel();
searchModel2 = SearchBc.Instance.SearchNearbyServiceProviders(searchModel2);
result = searchModel2.Result;
}
}
return(result);
}
public static SeoVm GetSeo(ServiceProvidersSearchVm result)
{
SeoVm seoVm = new SeoVm()
{
PageType = result.PageType,
CanonicalUrl = MslcUrlBuilder.PagingUrl(result, result.PageNumber),
LinkPrev = SeoHelper.FormPageLink <ServiceProviderBlockVm, ServiceProviderSortType>(result, PageDirection.Previous),
LinkNext = SeoHelper.FormPageLink <ServiceProviderBlockVm, ServiceProviderSortType>(result, PageDirection.Next),
MarketCopy = SeoBc.Instance.GetServiceProvidersMarketCopy(result.Criteria.ToSearchCriteria())
};
PageType pageType = seoVm.PageType;
if (pageType == PageType.ServiceProvidersByState)
{
seoVm.Title = Title.SearchServicesByState;
seoVm.Description = Description.SearchServicesByState;
seoVm.Header = Header.SearchServicesByState;
}
else if (pageType == PageType.ServiceProvidersByCity)
{
seoVm.Title = Title.SearchServicesByCity;
seoVm.Description = Description.SearchServicesByCity;
seoVm.Header = Header.SearchServicesByCity;
}
seoVm.Title = seoVm.Title.Replace <ServiceProviderBlockVm, ServiceProviderSortType>(result);
seoVm.Description = seoVm.Description.Replace <ServiceProviderBlockVm, ServiceProviderSortType>(result);
seoVm.Header = seoVm.Header.Replace <ServiceProviderBlockVm, ServiceProviderSortType>(result);
seoVm.MarketCopy = seoVm.MarketCopy.Replace <ServiceProviderBlockVm, ServiceProviderSortType>(result);
return(seoVm);
}
private void BindListingsSearchModel(ServiceProvidersSearchVm model, ControllerContext controllerContext, PropertyDescriptor propertyDescriptor)
{
if (string.Equals(propertyDescriptor.Name, "ServiceCategories"))
{
string text = controllerContext.HttpContext.Request["service-categories"] ?? controllerContext.HttpContext.Request["ServiceCategories"];
model.ServiceCategories = new List <int>();
if (!string.IsNullOrWhiteSpace(text))
{
model.ServiceCategories = (from pair in text.Split('-', ',').Select(delegate(string str)
{
int result;
bool success = int.TryParse(str, out result);
return(new
{
value = result,
success = success
});
})
where pair.success
select pair.value).Distinct().ToList();
return;
}
}
if (string.Equals(propertyDescriptor.Name, "SortType"))
{
string sortType = controllerContext.HttpContext.Request["sort-by"] ?? controllerContext.HttpContext.Request["SortType"];
model.SortType = sortType.FromServiceProviderSortTypeUrlStr();
}
}
internal static NearbySearchModel ToNearbySearchModel(this ServiceProvidersSearchVm searchVm)
{
return(new NearbySearchModel()
{
Criteria = searchVm.Criteria.ToSearchCriteria(),
MaxCount = SearchExtentions.Config.NearbyCitiesMaxCount
});
}
public static string PagingUrl(ServiceProvidersSearchVm model, int pageNumber)
{
return(model.PageType.FluentUrl().State(model.Criteria.StateCode()).Zip(model.Criteria.Zip())
.City(model.Criteria.City())
.Refined(RefinedParameters(model))
.WithPaging(pageNumber)
.Url());
}
internal static ServiceProviderRefineVm MapToServiceProviderRefineVm(this ServiceProvidersSearchVm searchVm)
{
ServiceProviderRefineVm serviceProviderRefineVm = new ServiceProviderRefineVm();
List <KeyValuePair <int, string> > shcCategoriesForServiceProvider = ItemTypeBc.Instance.GetShcCategoriesForServiceProvider();
serviceProviderRefineVm.ServiceCategories = shcCategoriesForServiceProvider.MapToSelectListItemList(searchVm.ServiceCategories);
serviceProviderRefineVm.SortTypes = ConverterHelper.EnumToKoSelectListItems <ServiceProviderSortType>(searchVm.SortType);
return(serviceProviderRefineVm);
}
public static LeadFormVm GetLeadFormVm(ServiceProvidersSearchVm vm)
{
LeadFormVm leadFormVm = GetLeadFormVm();
leadFormVm.Message = vm.GetLeadFormMessage();
leadFormVm.Brand = vm.PageType.ToSearchType().MapToBrandType();
leadFormVm.Inquiry = InquiryType.ServiceProvider;
leadFormVm.DisplayProperties.MoveInDate = false;
return(leadFormVm);
}
internal static PagingVm MapToPagingVm(this ServiceProvidersSearchVm searchVm)
{
PagingVm pagingVm = MapToCommonPagingVm(searchVm);
foreach (PageLinkVm page in pagingVm.Pages)
{
page.Href = MslcUrlBuilder.PagingUrl(searchVm, page.PageNumber);
}
return(pagingVm);
}
protected override void BindProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor)
{
ServiceProvidersSearchVm serviceProvidersSearchVm = bindingContext.Model as ServiceProvidersSearchVm;
base.BindProperty(controllerContext, bindingContext, propertyDescriptor);
if (serviceProvidersSearchVm != null)
{
BindListingsSearchModel(serviceProvidersSearchVm, controllerContext, propertyDescriptor);
}
}
internal static ServiceProviderSearchModel ToServiceProviderSearchModel(this ServiceProvidersSearchVm searchVm)
{
return(new ServiceProviderSearchModel()
{
Criteria = searchVm.Criteria.ToSearchCriteria(),
PageNumber = searchVm.PageNumber,
PageSize = SearchExtentions.Config.DefaultPageSize,
ServiceCategoriesIds = (
from a in searchVm.ServiceCategories
select(long) a).ToList <long>(),
SortType = searchVm.SortType
});
}
public static List <ServiceProviderBlockVm> GetNewSmililarServiceProvider(ServiceProvidersSearchVm searchVm, long CommunityId)
{
Entities.Client.Search.FeaturedServiceProviderSearchModel searchModel2 = searchVm.ToFeaturedServiceProviderSearchModel();
return(SearchBc.Instance.SearchFeaturedServiceProviders(searchModel2, CommunityId).Result.MapToServiceProviderBlockVmList());
}
public static string GetLeadFormMessage(this ServiceProvidersSearchVm searchVm)
{
return(LeadFormMessages.ServiceProvider.Replace("{SERVICE_PROVIDER_NAME}", string.Empty));
}
private static IEnumerable <KeyValuePair <string, object> > RefinedParameters(ServiceProvidersSearchVm model)
{
RouteValueDictionary routeValueDictionary = new RouteValueDictionary();
if (model.ServiceCategories != null && model.ServiceCategories.Any())
{
routeValueDictionary.Add("service-categories", string.Join("-", model.ServiceCategories));
}
if (model.SortType != ServiceProviderSortType.Featured && model.SortType != 0)
{
routeValueDictionary.Add("sort-by", model.SortType.ToSortTypeUrlStr());
}
return(routeValueDictionary);
}
