public SearchResult GetAllForCrag(string cragSlug, string country, ZlaggableCategoryEnum category, string sectorSlug = "", int pageIndex = 0, int pageSize = 50, string sortField = "", int?minGrade = null, int?maxGrade = null)
{
return(_elasticService.GetZlaggablesWithStatisticsForCrag(cragSlug, country, category, sectorSlug,
pageIndex, pageSize, sortField, minGrade, maxGrade));
/*
* var crags = _statisticsService.GetCragStatistics();
* List<ZlaggableWithStatistics> zlaggables = null;
*
* var query = crags.Single(c =>
* c.Category.Equals(category) &&
* c.Slug.Equals(cragSlug) &&
* c.CountrySlug.Equals(country))
* .Sectors as IEnumerable<WithStatisticsBase>;
*
* if (!string.IsNullOrWhiteSpace(sectorSlug))
* {
* query = query.Where(s => s.Slug.Equals(sectorSlug));
* }
*
* zlaggables = query
* .SelectMany(s => s.Children)
* .OrderByDescending(c => c.TotalAscents)
* .Skip(pageIndex * pageSize)
* .Take(pageSize)
* .ToList().ConvertAll(x => (ZlaggableWithStatistics)x);
*
* return zlaggables;
*/
}
public static void AddGrade(int zlaggableId, GradingSystem gradingSystem, ZlaggableCategoryEnum category)
{
HashSet <int> grades;
if (category == ZlaggableCategoryEnum.Sportclimbing)
{
if (routeGrades.ContainsKey(zlaggableId))
{
grades = routeGrades[zlaggableId];
}
else
{
grades = new HashSet <int>();
routeGrades.Add(zlaggableId, grades);
}
}
else
{
if (boulderGrades.ContainsKey(zlaggableId))
{
grades = boulderGrades[zlaggableId];
}
else
{
grades = new HashSet <int>();
boulderGrades.Add(zlaggableId, grades);
}
}
grades.Add(gradingSystem.VLGradeIndex);
}
public List <CragWithStatistics> GetAll(ZlaggableCategoryEnum category, string country = "", int pageIndex = 0, string sortField = "totalascents_desc")
{
if (string.IsNullOrEmpty(sortField))
{
sortField = "totalascents_desc";
}
return(_cragsManager.GetCragsWithStatisticsByCategory(category, country, pageIndex, sortField));
}
public List <Ascent> GetAllForRoute(string zlaggableSlug, string sectorSlug, ZlaggableCategoryEnum category, int pageIndex = 0, string sortField = "date_desc")
{
if (string.IsNullOrEmpty(sortField))
{
sortField = "date_desc";
}
return(_ascentsManager.GetAllForZlaggable(zlaggableSlug, category, sectorSlug, pageIndex, sortField));
}
public List <CragWithStatistics> GetCragsWithStatisticsByCategory(ZlaggableCategoryEnum category,
string countrySlug = "", int pageIndex = 0, int pageSize = 50, string sortField = "")
{
var client = GetElasticClient();
var descriptor = new SearchDescriptor <CragWithStatistics>();
descriptor.Query(q => q
.Term(c => c.Category, category) && q
.Term(z => z.CountrySlug, countrySlug)
)
.Size(pageSize)
.Skip(pageIndex * pageSize);
sortField = sortField.Trim().ToLower();
if (string.IsNullOrWhiteSpace(sortField))
{
sortField = "totalascents_desc";
}
var sortOrder = sortField.EndsWith("_desc") ? SortOrder.Descending : SortOrder.Ascending;
if (sortOrder == SortOrder.Descending)
{
sortField = sortField.Replace("_desc", "");
}
switch (sortField)
{
case "name":
descriptor.Sort(ss => ss.Field(f => f.Field(c => c.Name.Suffix("keyword")).Order(sortOrder)));
break;
case "country":
descriptor.Sort(ss => ss.Field(f => f.Field(c => c.CountryName.Suffix("keyword")).Order(sortOrder)));
break;
case "totalascents":
descriptor.Sort(ss => ss.Field(f => f.Field(c => c.TotalAscents).Order(sortOrder)));
break;
case "averagerating":
descriptor.Sort(ss => ss.Field(f => f.Field(c => c.AverageRating).Order(sortOrder)));
break;
default:
descriptor.Sort(ss => ss.Field(f => f.Field(c => c.TotalAscents).Order(sortOrder)));
break;
}
var response = client.Search <CragWithStatistics>(descriptor);
return(response.Documents.ToList());
}
public List <Ascent> GetAllForZlaggable(int routeId, ZlaggableCategoryEnum category, int pageIndex = 0, int pageSize = 50, string sortField = "")
{
var zlaggableType = category.Equals(ZlaggableCategoryEnum.Sportclimbing) ? "Route" : "Boulder";
IQueryable <Ascent> ascents = Context.Set <Ascent>()
.Where(a => a.ZlaggableType.Equals(zlaggableType) && a.ZlaggableId.Equals(routeId))
.Include(a => a.User);
sortField = sortField.Trim().ToLower();
if (string.IsNullOrWhiteSpace(sortField))
{
sortField = "date_desc";
}
var sortOrderDescending = sortField.EndsWith("_desc");
if (sortOrderDescending)
{
sortField = sortField.Replace("_desc", "");
}
switch (sortField)
{
case "username":
ascents = sortOrderDescending ? ascents.OrderByDescending(a => a.User.FirstName) : ascents.OrderBy(a => a.User.FirstName);
break;
case "date":
ascents = sortOrderDescending ? ascents.OrderByDescending(a => a.Date) : ascents.OrderBy(a => a.Date);
break;
case "style":
ascents = sortOrderDescending ? ascents.OrderByDescending(a => a.Style) : ascents.OrderBy(a => a.Style);
break;
case "notes":
ascents = sortOrderDescending ? ascents.OrderByDescending(a => a.Note) : ascents.OrderBy(a => a.Note);
break;
case "rating":
ascents = sortOrderDescending ? ascents.OrderByDescending(a => a.Rating) : ascents.OrderBy(a => a.Rating);
break;
default:
ascents = sortOrderDescending ? ascents.OrderByDescending(a => a.Date) : ascents.OrderBy(a => a.Date);
break;
}
return(ascents.Skip(pageIndex * pageSize).Take(pageSize).ToList());
}
public List <Ascent> GetAllForZlaggable(string zlaggableSlug, ZlaggableCategoryEnum category, string sectorSlug, int pageIndex = 0, string sortField = "", int pageSize = 50)
{
// get zlaggable from elasticsearch
var zlaggable = _elasticService.GetZlaggableWithStatistics(zlaggableSlug, category, sectorSlug);
if (zlaggable == null)
{
return(null);
}
/*
* _elasticService.GetAscentsForZlaggable(zlaggable.DatabaseId, zlaggable.Category, pageIndex, pageSize,
* sortField);
*/
return(_ascentsRepository.GetAllForZlaggable(zlaggable.DatabaseId, zlaggable.Category, pageIndex, pageSize, sortField));
}
public SearchResult GetAllForCrag(string cragSlug, string cragCountry, ZlaggableCategoryEnum category, string sectorSlug = "", int pageIndex = 0, int pageSize = 50, string sortField = "totalascents_desc", string grade = "")
{
if (string.IsNullOrEmpty(sortField))
{
sortField = "totalascents_desc";
}
int?minGrade = null;
int?maxGrade = null;
if (!string.IsNullOrEmpty(grade))
{
var arr = grade.Split(',');
minGrade = Convert.ToInt32(arr[0]);
maxGrade = arr.Length > 1 ? Convert.ToInt32(arr[1]) : minGrade;
}
return(_routesManager.GetAllForCrag(cragSlug, cragCountry, category, sectorSlug, pageIndex, pageSize, sortField, minGrade, maxGrade));
}
public List <CragWithStatistics> GetCragsWithStatisticsByCategory(ZlaggableCategoryEnum category, string countrySlug = "", int pageIndex = 0, string sortField = "", int pageSize = 50)
{
return(_elasticService.GetCragsWithStatisticsByCategory(category, countrySlug, pageIndex, pageSize, sortField));
/*
* var allCrags = _statisticsService.GetCragStatistics();
* List<CragWithStatistics> crags = null;
*
* var query = allCrags.Where(c => c.Category.Equals(category));
*
* if (!string.IsNullOrWhiteSpace(countrySlug))
* {
* query = query.Where(c => c.CountrySlug.Equals(countrySlug));
* }
*
* crags = query.OrderByDescending(c => c.TotalAscents)
* .Skip(pageIndex * pageSize)
* .Take(pageSize)
* .ToList();
*
* return crags;
*/
}
public ZlaggableWithStatistics Get(string zlaggableSlug, ZlaggableCategoryEnum category, string sectorSlug)
{
return(_routesManager.GetZlaggableWithStatistics(zlaggableSlug, category, sectorSlug));
}
public List <SectorWithStatistics> GetAllForCragWithPaging(string cragSlug, string cragCountry, ZlaggableCategoryEnum category, int pageIndex = 0,
int pageSize = 50)
{
return(_elasticService.GetSectorsWithStatisticsForCragWithPaging(cragSlug, cragCountry, category, pageIndex,
pageSize));
// return _sectorsRepository.GetAllForCragWithPaging(cragSlug, cragCountry, cragCategory, pageIndex, pageSize);
}
public List <SectorWithStatistics> GetSectorsWithStatisticsForCrag(string cragSlug, string cragCountry, ZlaggableCategoryEnum category)
{
return(_elasticService.GetSectorsWithStatisticsForCrag(cragSlug, cragCountry, category));
// return _sectorsRepository.GetSectorsWithStatisticsForCrag(cragSlug, cragCountry, cragCategory);
}
public List <SectorWithStatistics> GetSectorsWithStatisticsForCragWithPaging(string cragSlug, string cragCountry, ZlaggableCategoryEnum category,
int pageIndex = 0, int pageSize = 50)
{
var client = GetElasticClient();
var response = client.Search <SectorWithStatistics>(s => s
.Sort(ss => ss
.Field(f => f
.Field(c => c.Name)
.Order(SortOrder.Ascending)
)
)
.Query(q => q
.Term(o => o.CragSlug, cragSlug) && q
.Term(o => o.CountrySlug, cragCountry) && q
.Term(o => o.Category, category)
)
.Size(pageSize)
.Skip(pageIndex * pageSize)
);
return(response.Documents.ToList());
}
public List <SectorWithStatistics> GetSectorsWithStatisticsForCrag(string cragSlug, string countrySlug, ZlaggableCategoryEnum category)
{
var client = GetElasticClient();
var response = client.Search <SectorWithStatistics>(s => s
.Sort(ss => ss
.Field(f => f
.Field(c => c.Name.Suffix("keyword"))
.Order(SortOrder.Ascending)
)
)
.Query(q => q
.Term(o => o.CragSlug, cragSlug) && q
.Term(o => o.CountrySlug, countrySlug) && q
.Term(o => o.Category, category)
)
.Size(10000)
);
return(response.Documents.ToList());
}
public CragWithStatistics Get(string slug, string country, ZlaggableCategoryEnum category = ZlaggableCategoryEnum.Sportclimbing)
{
return(_cragsManager.GetCragWithStatistics(slug, country, category));
}
public List <SectorWithStatistics> GetAllForCragWithPaging(string cragSlug, string countrySlug, ZlaggableCategoryEnum category, int pageIndex = 0, int pageSize = 50)
{
return(_sectorsManager.GetAllForCragWithPaging(cragSlug, countrySlug, category, pageIndex, pageSize));
}
public CragWithStatistics GetCragWithStatistics(string cragSlug, string countrySlug, ZlaggableCategoryEnum category)
{
var client = GetElasticClient();
var response = client.Search <CragWithStatistics>(s => s
.Query(q => q
.Term(o => o.Slug, cragSlug) && q
.Term(o => o.CountrySlug, countrySlug) && q
.Term(o => o.Category, category)
));
return(response.Documents.SingleOrDefault());
}
public CragWithStatistics GetCragWithStatistics(string cragSlug, string countrySlug, ZlaggableCategoryEnum category)
{
return(_elasticService.GetCragWithStatistics(cragSlug, countrySlug, category));
//_elasticService.GetCragsWithStatisticsByCategory()
/*
* Console.WriteLine($"get crag: '{cragSlug}', category: '{category}', countrySlug: '{countrySlug}'");
* var allCrags = _statisticsService.GetCragStatistics();
* var crag = allCrags.SingleOrDefault(c => c.Category.Equals(category) && c.Slug.Equals(cragSlug) && c.CountrySlug.Equals(countrySlug));
* return crag;
*/
}
public List <SectorWithStatistics> GetAllForCrag(string cragSlug, string countrySlug, ZlaggableCategoryEnum category)
{
return(_sectorsManager.GetSectorsWithStatisticsForCrag(cragSlug, countrySlug, category));
}
public ZlaggableWithStatistics GetZlaggableWithStatistics(string zlaggableSlug, ZlaggableCategoryEnum category, string sectorSlug)
{
var client = GetElasticClient();
var response = client.Search <ZlaggableWithStatistics>(s => s
.Query(q => q
.Term(z => z.Slug, zlaggableSlug) && q
.Term(z => z.SectorSlug, sectorSlug) && q
.Term(z => z.Category, category)
));
return(response.Documents.SingleOrDefault());
}
public SearchResult GetZlaggablesWithStatisticsForCrag(string cragSlug, string countrySlug, ZlaggableCategoryEnum category,
string sectorSlug = "", int pageIndex = 0, int pageSize = 50, string sortField = "", int?minGrade = null, int?maxGrade = null)
{
var client = GetElasticClient();
var descriptor = new SearchDescriptor <ZlaggableWithStatistics>();
descriptor
.Size(pageSize)
.Skip(pageIndex * pageSize);
if (minGrade.HasValue && maxGrade.HasValue)
{
descriptor.Query(q => q
.Term(o => o.CragSlug, cragSlug) && q
.Term(o => o.SectorSlug, sectorSlug) && q
.Term(o => o.CountrySlug, countrySlug) && q
.Term(o => o.Category, category) && q
.Range(c => c
.Field(z => z.GradeIndex)
.GreaterThanOrEquals(minGrade.Value)
.LessThanOrEquals(maxGrade.Value)));
}
else
{
descriptor.Query(q => q
.Term(o => o.CragSlug, cragSlug) && q
.Term(o => o.SectorSlug, sectorSlug) && q
.Term(o => o.CountrySlug, countrySlug) && q
.Term(o => o.Category, category)
);
}
sortField = sortField.Trim().ToLower();
if (string.IsNullOrWhiteSpace(sortField))
{
sortField = "totalascents_desc";
}
var sortOrder = sortField.EndsWith("_desc") ? SortOrder.Descending : SortOrder.Ascending;
if (sortOrder == SortOrder.Descending)
{
sortField = sortField.Replace("_desc", "");
}
switch (sortField)
{
case "grade":
descriptor.Sort(ss => ss.Field(f => f.Field(c => c.GradeIndex).Order(sortOrder)));
break;
case "name":
descriptor.Sort(ss => ss.Field(f => f.Field(c => c.Name.Suffix("keyword")).Order(sortOrder)));
break;
case "totalascents":
descriptor.Sort(ss => ss.Field(f => f.Field(c => c.TotalAscents).Order(sortOrder)));
break;
case "ratio":
descriptor.Sort(ss => ss.Field(f => f.Field(c => c.FlashOnsightRate).Order(sortOrder)));
break;
case "recommended":
descriptor.Sort(ss => ss.Field(f => f.Field(c => c.TotalRecommendedRate).Order(sortOrder)));
break;
case "stars":
descriptor.Sort(ss => ss.Field(f => f.Field(c => c.AverageRating).Order(sortOrder)));
break;
default:
descriptor.Sort(ss => ss.Field(f => f.Field(c => c.TotalAscents).Order(sortOrder)));
break;
}
var response = client.Search <ZlaggableWithStatistics>(descriptor);
var result = new SearchResult()
{
Count = (int)response.Total,
Items = response.Documents.ToList <object>()
};
return(result);
}
public ZlaggableWithStatistics GetZlaggableWithStatistics(string zlaggableSlug, ZlaggableCategoryEnum category, string sectorSlug)
{
Console.WriteLine($"get zlaggable: '{zlaggableSlug}', category: '{category}'");
return(_elasticService.GetZlaggableWithStatistics(zlaggableSlug, category, sectorSlug));
/*
* var crags = _statisticsService.GetCragStatistics();
* ZlaggableWithStatistics zlaggable = null;
* zlaggable = crags
* .Where(c => c.Category.Equals(category))
* .SelectMany(c => c.Sectors)
* .SelectMany(s => s.Children)
* .SingleOrDefault(z => z.Slug.Equals(zlaggableSlug)) as ZlaggableWithStatistics;
* return zlaggable;
*/
}
