private SportData getSportDataExt(string param2)
{
string param = Consts.GET_SPORT_DATA + getParams();
try
{
String sleepInfo = webClient.Post(param, param2, CONTENT_TYPE);
SportData sportData = JsonConvert.DeserializeObject <SportData>(sleepInfo);
if (sportData == null || sportData.sport == null)
{
sportData = new SportData();
Sport sport = new Sport();
sportData.sport = sport;
}
return(sportData);
}
catch (Exception ex)
{
if (currentTryRunNum == TRY_AGAIN_MUN)
{
FailRequestManager.mInstance.saveInFailList(mUserModel.UserID, Convert.ToDateTime(mSyncDay), param, (ex == null ? "" : ex.Message));
return(null);
}
else
{
currentTryRunNum++;
return(getSportDataExt(param2));
}
}
}
public void GetSportForTournamentAsyncReturnNewLocaleTest()
{
//loads tournaments.xml for new locale
SportData dataNl = null; // with NL locale
SportData data01 = null; // without locale
Task.Run(async() =>
{
await _sportDataCache.GetSportsAsync(TestData.Cultures).ConfigureAwait(false); // initial load
dataNl = await _sportDataCache.GetSportForTournamentAsync(TournamentId, new[] { _cultureNl }); //add new locale
data01 = await _sportDataCache.GetSportForTournamentAsync(TournamentId, TestData.Cultures); // get all translations
}).GetAwaiter().GetResult();
Assert.IsNotNull(dataNl);
Assert.AreEqual(SportId, dataNl.Id);
BaseSportDataValidation(dataNl, 1);
Assert.IsNotNull(dataNl.Categories);
Assert.IsNotNull(dataNl.Categories.FirstOrDefault()?.Tournaments);
Assert.AreEqual(@"Voetbal", dataNl.Names[_cultureNl]);
Assert.AreEqual(@"Internationaal", dataNl.Categories.FirstOrDefault()?.Names[_cultureNl]);
Assert.AreEqual(URN.Parse("sr:tournament:1"), dataNl.Categories.FirstOrDefault()?.Tournaments.FirstOrDefault());
BaseSportDataValidation(data01, TestData.Cultures.Count);
}
public IActionResult Sports(string column, string value)
{
List <Dictionary <String, String> > sports = SportData.FindByColumnAndValue(column, value);
ViewBag.title = "Sports with " + columnChoices[column] + ": " + value;
ViewBag.sports = sports;
return(View());
}
private lifesense.Model.t_walkinfo getSportModel(SportData sportData, lifesense.Model.t_userinfo mUserInfoModel, string day)
{
lifesense.Model.t_walkinfo walkModel = new lifesense.Model.t_walkinfo();
walkModel.UserID = mUserInfoModel.UserID;
walkModel.MeasureTime = Convert.ToDateTime(day);
walkModel.StepNum = sportData.sport.stepCount;
walkModel.Calorie = Convert.ToDecimal(sportData.sport.calorie);
walkModel.Mileage = Convert.ToDecimal(sportData.sport.distance);
return(walkModel);
}
public void GetSportAsyncReturnUnknownIdTest()
{
var sportId = URN.Parse("sr:sport:11111111");
SportData data = null;
Task.Run(async() =>
{
data = await _sportDataCache.GetSportAsync(sportId, TestData.Cultures);
}).GetAwaiter().GetResult();
Assert.IsNull(data);
}
public void GetSportAsyncReturnKnownId2Test()
{
const string callType = "GetAllSportsAsync";
List <SportData> sportsList = _sportDataCache.GetSportsAsync(TestData.Cultures).Result.ToList(); // initial load
SportData data = _sportDataCache.GetSportAsync(SportId, TestData.Cultures).Result;
Assert.AreEqual(TestData.Cultures.Count, _dataRouterManager.GetCallCount(callType), $"{callType} should be called exactly {TestData.Cultures.Count} times.");
Assert.AreEqual(SportId, data.Id);
Assert.AreEqual("Soccer", data.Names[_cultureEn]);
BaseSportDataValidation(data);
foreach (var s in sportsList)
{
BaseSportDataValidation(s);
}
}
/// <summary>
/// Constructs and returns a new instance of <see cref="ISport"/> from the provided data
/// </summary>
/// <param name="sportData">A <see cref="SportData"/> instance containing info about the sport</param>
/// <param name="cultures">A <see cref="IEnumerable{CultureInfo}"/> specifying the languages to which the sport data is translated</param>
/// <param name="exceptionStrategy">A <see cref="ExceptionHandlingStrategy"/> enum member specifying how the build instance will handle potential exceptions</param>
/// <returns>The constructed <see cref="ISport"/> instance</returns>
private ISport BuildSportInternal(SportData sportData, IEnumerable <CultureInfo> cultures, ExceptionHandlingStrategy exceptionStrategy)
{
Guard.Argument(sportData, nameof(sportData)).NotNull();
Guard.Argument(cultures, nameof(cultures)).NotNull().NotEmpty();
var categories = sportData.Categories?.Select(categoryData => new Category(
categoryData.Id,
categoryData.Names,
categoryData.CountryCode,
categoryData.Tournaments.Select(tournamentUrn => BuildSportEvent <ISportEvent>(tournamentUrn, sportData.Id, cultures, exceptionStrategy)).ToList())).Cast <ICategory>().ToList();
return(new Sport(
sportData.Id,
sportData.Names,
categories));
}
/// <summary>
/// Constructs and returns a new instance of <see cref="ISport"/> from the provided data
/// </summary>
/// <param name="sportData">A <see cref="SportData"/> instance containing info about the sport</param>
/// <param name="cultures">A <see cref="IEnumerable{CultureInfo}"/> specifying the languages to which the sport data is translated</param>
/// <param name="exceptionStrategy">A <see cref="ExceptionHandlingStrategy"/> enum member specifying how the build instance will handle potential exceptions</param>
/// <returns>The constructed <see cref="ISport"/> instance</returns>
private ISport BuildSportInternal(SportData sportData, IEnumerable <CultureInfo> cultures, ExceptionHandlingStrategy exceptionStrategy)
{
Contract.Requires(sportData != null);
Contract.Requires(cultures != null && cultures.Any());
var categories = sportData.Categories?.Select(categoryData => new Category(
categoryData.Id,
categoryData.Names,
categoryData.CountryCode,
categoryData.Tournaments.Select(tournamentUrn => BuildSportEvent <ISportEvent>(tournamentUrn, sportData.Id, cultures, exceptionStrategy)).ToList())).Cast <ICategory>().ToList();
return(new Sport(
sportData.Id,
sportData.Names,
categories));
}
private bool saveSportData(SportData sportData, lifesense.Model.t_userinfo mUserInfoModel, string day)
{
if (sportData == null || sportData.sport == null)
{
return(false);
}
lifesense.Model.t_walkinfo sportModel = getSportModel(sportData, mUserInfoModel, day);
lifesense.BLL.t_walkinfo walkBll = new lifesense.BLL.t_walkinfo();
String strWhere = " UserId='" + mUserInfoModel.UserID + "' and MeasureTime='" + sportModel.MeasureTime + "'";
List <lifesense.Model.t_walkinfo> walkInfoList = walkBll.GetModelList(strWhere);
if (walkInfoList != null && walkInfoList.Count <= 0)
{
return(walkBll.Add(sportModel) > 0 ? true : false);
}
return(true);
}
public IActionResult Values(string column)
{
if (column.Equals("all"))
{
List <Dictionary <string, string> > sports = SportData.FindAll();
ViewBag.title = "All Sports";
ViewBag.sports = sports;
return(View("Sports"));
}
else
{
List <string> items = SportData.FindAll(column);
ViewBag.title = "All " + columnChoices[column] + " Values";
ViewBag.column = column;
ViewBag.items = items;
return(View());
}
}
private static void BaseSportDataValidation(SportData data, int cultureNbr)
{
Assert.IsNotNull(data);
Assert.IsNotNull(data.Names);
Assert.AreEqual(cultureNbr, data.Names.Count);
if (data.Categories != null)
{
foreach (var i in data.Categories)
{
Assert.IsNotNull(i.Id);
Assert.AreEqual(cultureNbr, i.Names.Count);
foreach (var j in i.Tournaments)
{
Assert.IsNotNull(j.Id);
}
}
}
}
public void GetSportAsyncReturnKnownIdTest()
{
const string callType = "GetAllSportsAsync";
SportData data = null;
List <SportData> sportsList = null;
Task.Run(async() =>
{
var sports = await _sportDataCache.GetSportsAsync(TestData.Cultures).ConfigureAwait(false); // initial load
sportsList = sports.ToList();
data = await _sportDataCache.GetSportAsync(SportId, TestData.Cultures);
}).GetAwaiter().GetResult();
Assert.AreEqual(TestData.Cultures.Count, _dataRouterManager.GetCallCount(callType), $"{callType} should be called exactly {TestData.Cultures.Count} times.");
Assert.AreEqual(SportId, data.Id);
Assert.AreEqual("Soccer", data.Names[_cultureEn]);
BaseSportDataValidation(data);
foreach (var s in sportsList)
{
BaseSportDataValidation(s);
}
}
// Results action method to process search request and display results
public IActionResult Results(string searchType, string searchTerm)
{
ViewBag.columns = ListController.columnChoices;
List <Dictionary <string, string> > sports = new List <Dictionary <string, string> >();
if (string.IsNullOrEmpty(searchTerm))
{
return(View("Index"));
}
if (searchType.Equals("all"))
{
sports = SportData.FindByValue(searchTerm);
ViewBag.sports = sports;
return(View("Index"));
}
else
{
sports = SportData.FindByColumnAndValue(searchType, searchTerm);
ViewBag.sports = sports;
return(View("Index"));
}
}
public void ConcurrencyFetchTest()
{
IEnumerable <SportData> sports = null;
SportData sport = null;
SportData tournamentSport = null;
TournamentInfoCI tournament = null;
IEnumerable <Tuple <URN, URN> > tournamentEvents = null;
IEnumerable <Tuple <URN, URN> > dateEvents = null;
for (var i = 0; i < 5; i++)
{
Task.Run(async() =>
{
_sportDataCache.FetchedCultures.Clear();
sports = await _sportDataCache.GetSportsAsync(TestData.Cultures);
sport = await _sportDataCache.GetSportAsync(TestData.SportId, TestData.Cultures);
tournamentSport = await _sportDataCache.GetSportForTournamentAsync(URN.Parse("sr:tournament:146"), TestData.Cultures);
tournamentEvents = await _sportEventCache.GetEventIdsAsync(TestData.TournamentId, _cultureEn);
tournament = (TournamentInfoCI)_sportEventCache.GetEventCacheItem(TestData.TournamentId);
dateEvents = await _sportEventCache.GetEventIdsAsync(DateTime.Now, _cultureEn);
}).GetAwaiter().GetResult();
Assert.IsNotNull(sports, "Retrieved sports cannot be null");
// ReSharper disable once PossibleMultipleEnumeration
foreach (var s in sports)
{
BaseSportDataValidation(s);
}
Assert.IsNotNull(sport, "sport cannot be a null reference");
Assert.IsNotNull(tournament, "tournament cannot be a null reference");
Assert.IsNotNull(tournamentEvents, "tournamentEvents cannot be a null reference");
Assert.IsNotNull(dateEvents, "dateEvents cannot be a null reference");
Assert.AreEqual(1, tournamentSport.Categories.Count(), "The number of categories must be 1");
Assert.AreEqual(1, tournamentSport.Categories.First().Tournaments.Count(), "the number of tournaments must be 1");
}
}
private void BaseSportDataValidation(SportData data)
{
BaseSportDataValidation(data, TestData.Cultures.Count);
}
