private static List<RawCompetitor> GetRawCompetitorInt(BrokerType brokerType, LanguageType languageType, SportType sportType, GenderType genderType, string[] names)
{
if (genderType == GenderType.Unknown) {
_logger.Error("{0}: {1}", names.StrJoin(", "), genderType);
}
var competitorsRaw = RawCompetitor.DataSource.FilterByLanguage(languageType).FilterBySportType(sportType).FilterByBroker(brokerType)
.FilterByNameCompetitor(names)
.FilterByGender(genderType,
RawCompetitor.Fields.CompetitoruniqueID,
RawCompetitor.Fields.Name,
RawCompetitor.Fields.Linkstatus);
if (competitorsRaw.Count > 1) {
var groupBy = competitorsRaw.Where(c => c.CompetitoruniqueID != default(int)).GroupBy(c => c.CompetitoruniqueID).ToArray();
if (groupBy.Length > 1) {
_logger.Error("{0} {1} {2} {3} {4} <=> {5}", brokerType, sportType, genderType,
competitorsRaw.Select(cr => cr.ID).StrJoin(", "), names.StrJoin(", "), groupBy.Select(g => g.Select(ge => ge.Name).StrJoin(", ")).StrJoin(" | "));
return groupBy.First().ToList();
}
if (groupBy.Length == 1) {
foreach (var rawCompetitor in competitorsRaw.Where(cr => cr.CompetitoruniqueID == default(int))) {
rawCompetitor.CompetitoruniqueID = groupBy[0].Key;
rawCompetitor.Save();
}
}
}
return CreateRawCompetitor(names, competitorsRaw, brokerType, languageType, sportType, genderType);
}
private ActionResult BuildActionResult(SportType sportType, Dictionary<DateTime, List<Dictionary<BetOddType, BetItemTransport>>> data)
{
return new ActionResultCached(data != null,
() => data.MaxOrDefault(d => d.Key, DateTime.MinValue),
() => {
var res = new List<Dictionary<string, double>>();
var addDraw = BetHelper.SportTypeWithOdds[sportType].Contains(BetOddType.Draw);
data
.OrderBy(d => d.Key)
.Each(betItems => {
var list = betItems.Value;
var dict = new Dictionary<string, double> {
{"d", (betItems.Key - ProjectBConsts.DefaultLinuxUtc).TotalMilliseconds},
{"w1", BetOddInterfaceHelper.GetOddValue(sportType, BetOddType.Win1, list, Enumerable.Max)},
{"w2", BetOddInterfaceHelper.GetOddValue(sportType, BetOddType.Win2, list, Enumerable.Max)},
{"r1x2", BetOddInterfaceHelper.GetBetOddRoi(RoiType.Roi1X2, sportType, list)},
{"h1", BetOddInterfaceHelper.GetOddValue(sportType, BetOddType.Handicap1, list, Enumerable.Max)},
{"h2", BetOddInterfaceHelper.GetOddValue(sportType, BetOddType.Handicap2, list, Enumerable.Max)},
{"rh", BetOddInterfaceHelper.GetBetOddRoi(RoiType.RoiHandicap, sportType, list)},
{"tu", BetOddInterfaceHelper.GetOddValue(sportType, BetOddType.TotalUnder, list, Enumerable.Max)},
{"to", BetOddInterfaceHelper.GetOddValue(sportType, BetOddType.TotalOver, list, Enumerable.Max)},
{"rt", BetOddInterfaceHelper.GetBetOddRoi(RoiType.RoiTotal, sportType, list)},
};
if (addDraw) {
dict["x"] = BetOddInterfaceHelper.GetOddValue(sportType, BetOddType.Draw, list, Enumerable.Max);
}
res.Add(dict);
});
return new JsonResult {
Data = res
};
});
}
public Match(SportType sport, League league, DateTime dateTime, string homeTeam, string visitorTeam)
{
/*
* var dateToBeChecked = dateTime.AddHours(2);
*
* if (DateTime.Now > dateToBeChecked)
* {
* throw new ArgumentException("Cannot add match that is expired.");
* }
*/
if (homeTeam == visitorTeam)
{
throw new ArgumentException(EngineConstants.SameTeamsInMatchErrorMessage);
}
this.Sport = sport;
this.League = league;
this.Date = dateTime;
this.HomeTeam = homeTeam;
this.VisitorTeam = visitorTeam;
this.Id = lastUsedId + 1;
lastUsedId = this.Id;
this.Bets = new List <IBet>();
this.Results = new Dictionary <ResultType, IResult>();
}
public long CreateLeague(string name, long userId, SportType sport)
{
if (string.IsNullOrEmpty(name))
{
throw new BusinessException(ErrorCodes.LeagueNameRequired, "League name is required.");
}
var leagueName = name.Trim();
if (!IsValidateLeagueName(leagueName))
{
throw new BusinessException(ErrorCodes.InvalidLeagueName, "League name must be between 5 and 50 alphanumeric characters");
}
var league = new League
{
CreatorUserId = userId,
Name = leagueName,
OwnerUserId = userId,
Sport = sport
};
var leagueId = _leagueRepository.CreateLeague(league);
_leagueRepository.AddMember(leagueId, userId);
return leagueId;
}
public override void OnInspectorGUI()
{
serializedObject.Update();
ItemGenerator myTarget = (ItemGenerator)target;
EditorGUILayout.PropertyField(state_Prop);
SportType st = (SportType)state_Prop.enumValueIndex;
switch (st)
{
case SportType.DOWNHILL:
EditorGUILayout.PropertyField(dh_playerController, true, new GUILayoutOption[0]);
EditorGUILayout.PropertyField(dh_standardChangeMeters, new GUIContent("dh_standardChangeMeters"), true);
EditorGUILayout.PropertyField(dh_intervalMeters, new GUIContent("dh_intervalMeters"), true);
EditorGUILayout.PropertyField(dh_itemAreas, new GUIContent("dh_itemAreas"), true);
EditorGUILayout.PropertyField(dh_numPerGenerates, new GUIContent("dh_numPerGenerates"), true);
break;
case SportType.SKELETON:
break;
case SportType.SKIJUMP:
EditorGUILayout.PropertyField(sj_playerController, true, new GUILayoutOption[0]);
EditorGUILayout.PropertyField(sj_standardChangeMeter, new GUIContent("sj_standardChangeMeter"), true);
EditorGUILayout.PropertyField(sj_intervalMeter, new GUIContent("sj_intervalMeter"), true);
EditorGUILayout.PropertyField(sj_numPerGenerate, new GUIContent("sj_numPerGenerate"), true);
break;
}
EditorGUILayout.PropertyField(items, new GUIContent("items"), true);
EditorGUILayout.PropertyField(parent, new GUIContent("parent"), true);
serializedObject.ApplyModifiedProperties();
}
public void ResolveNamingNeutralTest()
{
IUnitOfWork unit = new EFUnitOfWork(this.databaseSportsContext);
SportType football = new SportType {
Name = "Football"
};
SportType sport = unit.GetRepository <SportType>()
.Get(x => x.Name.ToUpper() == football.Name.ToUpper())
.FirstOrDefault();
Conformity expConf = new Conformity
{
InputName = "Ст. Этьен",
ExistedName = "Сент-Этьен"
};
Team neutralTeam = new Team
{
Name = "Ст. Этьен",
SportType = sport
};
NamingMatcher matcher = new NamingMatcher(unit);
List <Conformity> neutralConformities = matcher.ResolveNaming(neutralTeam);
Conformity newConf = neutralConformities.FirstOrDefault();
Assert.AreEqual(expConf.InputName, newConf.InputName);
Assert.AreEqual(expConf.ExistedName, newConf.ExistedName);
}
public void Delete(int ID)
{
SportType selectedItem = _SportType.Find(ID);
selectedItem.IsDeleted = true;
selectedItem.UpdatedOn = DateTime.Now;
}
public void ResolveNamingNegativeTest()
{
IUnitOfWork unit = new EFUnitOfWork(this.databaseSportsContext);
SportType football = new SportType {
Name = "Football"
};
SportType sport = unit.GetRepository <SportType>()
.Get(x => x.Name.ToUpper() == football.Name.ToUpper())
.FirstOrDefault();
Team negativeTeam = new Team
{
Name = "Металлист",
SportType = sport,
Names = new List <TeamName>()
};
NamingMatcher matcher = new NamingMatcher(unit);
List <Conformity> negativeConformities = matcher.ResolveNaming(negativeTeam);
Assert.IsNull(negativeConformities);
Team team = unit.GetRepository <Team>()
.Get((x) => x.Id == negativeTeam.Id)
.FirstOrDefault();
Assert.AreEqual(negativeTeam, team);
}
//-----------------------------------------------------
private IActionResult UpdatGet(int clientId)
{
var clt = _clientManager.GetClient(clientId);
var cltVM = clt.ToClientVM();
// 2. Map all derived fields ---------
cltVM.ClientFullName = clt.FirstName + " " + clt.LastName;
cltVM.AgeInDays = (int)(DateTime.Today.Subtract(clt.BirthDate)).TotalDays;
cltVM.NrofPrescriptions = _clientManager.GetNrOfPrescrPerClient(clt.Id);
cltVM.DoctorFullName = _clientManager.DoctorFullName(clt.DoctorId);
// Alle landen toevoegen aan UPDATE scherm, ivm dropdownlist
// TODO: hoe toon ik het land van deze client als default?
cltVM.Countries = _countryManager.GetAllCountries();
CreateListOfZodiacs(cltVM); // cltVM is call by reference
// zoek index in Enum op van de betreffende sterrenbeeld
// zodat deze als eerste wordt getoond in de view:
AstrologyZodiacSign zodiacSign = (AstrologyZodiacSign)Enum.Parse(typeof(AstrologyZodiacSign), clt.AstrologyZodiacSign);
cltVM.ZodiacId = (int)zodiacSign;
CreateListOfSportTypes(cltVM); // cltVM is call by reference
// zoek index in Enum op van de betreffende sterrenbeeld
// zodat deze als eerste wordt getoond in de view:
SportType sportType = (SportType)Enum.Parse(typeof(SportType), clt.TypeOfSporter);
cltVM.SportTypeId = (int)sportType;
return(View(cltVM));
}
/// <summary>
/// Query to generate a list of activities which match given criteria
/// </summary>
/// <param name="userId">ASP.NET Identity Id</param>
/// <param name="sport">Run, Ride, Swim, Other, All</param>
/// <param name="start">Beginning of date range</param>
/// <param name="end">End of date range</param>
/// <returns></returns>
public IQueryable <ActivityDto> GetSportSummaryQuery(string userId, SportType sport, DateTime start, DateTime end)
{
ActivityRepository activityRepo = new ActivityRepository(_context);
IQueryable <ActivityDto> activityQuery = activityRepo.ActivitiesBySport(userId, sport)
.Include(r => r.ActivityType)
.Where(r => r.Start >= start && r.Start <= end)
.Select(r => new ActivityDto
{
Id = r.Id,
Name = r.Name,
ActivityTypeId = r.ActivityTypeId,
MovingTime = r.MovingTime != null ? r.MovingTime.Value : new TimeSpan(0, 0, 0),
Distance = r.Distance,
SufferScore = r.SufferScore != null ? r.SufferScore.Value : 0,
Calories = r.Calories,
ElevationGain = r.ElevationGain,
Start = r.Start,
StartDateLocal = r.StartDateLocal,
HasMap = r.StartLatitude != null ? true : false,
IsRide = r.ActivityType.IsRide,
IsRun = r.ActivityType.IsRun,
IsSwim = r.ActivityType.IsSwim,
IsOther = r.ActivityType.IsOther,
DetailsDownloaded = r.DetailsDownloaded,
HasPowerMeter = r.HasPowerMeter,
TSS = r.TSS != null ? r.TSS : 0
});
return(activityQuery);
}
public bool SecondaryEvenTileExists(SportType sport, int eventId)
{
var tileParms = string.Format(EventSecondaryTileQuery, eventId, (int)sport);
var secondaryTile = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString().Contains(tileParms));
return secondaryTile != null;
}
public async Task <SportType> AddAsync(SportType newSportType, CancellationToken ct = default)
{
this._dbContext.SportTypes.Add(newSportType);
await this._dbContext.SaveChangesAsync(ct);
return(newSportType);
}
public async Task <IActionResult> Edit(string id, [Bind("Name,Description")] SportType sportType)
{
if (id != sportType.Name)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(sportType);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SportTypeExists(sportType.Name))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(sportType));
}
private static List<RawCompetitor> CreateRawCompetitor(string[] names, List<RawCompetitor> competitorsRaw, BrokerType brokerType, LanguageType languageType, SportType sportType, GenderType genderType)
{
var existNames = competitorsRaw.Select(cr => cr.Name).ToList();
names = names
.Where(name => !existNames.Contains(name))
.ToArray();
if (names.Any()) {
var lastCompetitorUniqueID = competitorsRaw.Any()
? competitorsRaw.First().CompetitoruniqueID
: default(int);
var raw = competitorsRaw;
names
.Where(name => !raw.Any(c => c.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)))
.Each(name => {
RawCompetitor competitorRaw = null;
try {
competitorRaw = BrokerEntityIfaceCreator.CreateEntity<RawCompetitor>(brokerType, languageType, sportType, genderType, LinkEntityStatus.Unlinked, new[] { name },
competitor => {
if (lastCompetitorUniqueID != default(int)) {
competitor.CompetitoruniqueID = lastCompetitorUniqueID;
competitor.Linkstatus = LinkEntityStatus.LinkByStatistics | LinkEntityStatus.Linked;
}
});
competitorRaw.Save();
raw.Add(competitorRaw);
} catch (Exception ex) {
_logger.Error("{0}\r\n{1}", competitorRaw?.ToString(), ex);
throw;
}
});
}
return competitorsRaw;
}
internal IQueryable <Activity> ActivitiesBySport(string userId, SportType sport)
{
// get activities which fall into the selected weeks.
var activitiesQuery = _context.Activity
.Include(r => r.ActivityType)
.Include(r => r.Athlete)
.Where(r => r.Athlete.UserId == userId);
if (sport == SportType.Ride)
{
return(activitiesQuery.Where(r => r.ActivityType.IsRide));
}
else if (sport == SportType.Run)
{
return(activitiesQuery.Where(r => r.ActivityType.IsRun));
}
else if (sport == SportType.Swim)
{
return(activitiesQuery.Where(r => r.ActivityType.IsSwim));
}
else if (sport == SportType.Other)
{
return(activitiesQuery.Where(r => r.ActivityType.IsOther));
}
else
{
return(activitiesQuery);
}
}
/// <summary>
/// Calculate Daily information for a given sport.
/// </summary>
/// <param name="sport"></param>
private void Calculate(SportType sport)
{
int sequence = 0;
decimal runningYTDDistance = 0;
foreach (YearlyDetailsDayInfo i in _details.Where(a => a.Sport == sport))
{
if (i.Date.Month == 1 && i.Date.Day == 1)
{
runningYTDDistance = 0;
}
runningYTDDistance += i.Distance;
i.YTDDistance = runningYTDDistance;
if (i.Distance > 0)
{
i.Sequence = ++sequence;
}
else
{
sequence = 0;
}
}
}
public async Task <bool> UpdateSportTypeAsync(SportTypeViewModel sportTypeToUpdate, CancellationToken ct = default(CancellationToken))
{
SportType sportType = await _sportTypeRepository.GetByIdAsync(sportTypeToUpdate.Id, ct);
if (sportType == null)
{
return(false);
}
sportType.Name = sportTypeToUpdate.Name;
sportType.Active = sportTypeToUpdate.Active;
// if sport type successfully updated, update all of its leagues
if (await this._sportTypeRepository.UpdateAsync(sportType, ct))
{
// when the sport type name changes we also need to update all of the associated leagues type property
// since the type property on the league represents the name of the sport
List <LeagueViewModel> leagues = await GetLeaguesBySportTypeIdAsync(sportType.Id);
List <LeagueViewModel> updatedLeagues = new List <LeagueViewModel>();
foreach (LeagueViewModel league in leagues)
{
league.Type = sportTypeToUpdate.Name;
updatedLeagues.Add(league);
}
return(await UpdateLeaguesAsync(updatedLeagues, ct));
}
// if updating sport type failed
return(false);
}
private static CompetitionItemRoiRow[] BuildResult(DbStoredProc proc, SportType sportType, int[] competitionUniqueIDs, BrokerType[] brokerTypes)
{
if (brokerTypes != null) {
proc = proc.WithParam("argbrokerids", brokerTypes.Select(b => (short)b), DbType.Int16);
}
if (competitionUniqueIDs != null) {
proc = proc.WithParam("argcompetitionuniqueids", competitionUniqueIDs, DbType.Int32);
}
if (sportType != SportType.Unknown) {
proc = proc.WithParam("argsporttype", (short) sportType);
}
var data = proc.MultiRowExec(DatabaseActions.GetAdapter(TargetDB.MASTER), "fn_getbetroi").Data;
var result = new CompetitionItemRoiRow[data.Count];
for (var i = 0; i < result.Length; i++) {
var row = data[i];
var betData = (int[])row[1];
var betIDs = new Dictionary<BetOddType, int>();
for (var j = 0; j < betData.Length; j+=2) {
betIDs[(BetOddType) (short) betData[j]] = betData[j + 1];
}
result[i] = new CompetitionItemRoiRow {
ID = (int)row[0],
BetIDs = betIDs,
Roi = (float) row[2],
RoiType = (RoiType) (short) row[3]
};
}
return result;
}
private static Player GetPlayer(DirectoryInfo directory, SportType sportType)
{
var fullPlayerName = directory.Name;
var split = fullPlayerName.Split(" ");
List <Player> players;
Player player;
string firstName = split[0];
string lastName = split.Length > 1 ? split[1] : "";
players = _playerDBService.Get(firstName, lastName);
if (players == null || players.Count == 0)
{
players = _playerDBService.Get(lastName, firstName);
}
if (players != null && players.Count > 0)
{
player = players[0];
}
else
{
player = _playerDBService.Create(new Player
{
Id = Guid.NewGuid().ToString(),
FirstName = firstName,
LastName = lastName,
SportType = sportType
});
}
return(player);
}
/// <summary>
/// Saves sport to a database
/// </summary>
/// <param name="o">Leave it empty</param>
private async void SaveSportType(object o)
{
SportType = new SportType
{
Id = SportTypeId ?? -1,
Name = SportTypeName,
Description = SportTypeDescription
};
_cts.Cancel();
_cts = new CancellationTokenSource();
ErrorText = "Trwa zapisywanie...";
var success = await _sportTypeProxy.SaveSportType(SportType);
if (success)
{
ErrorText = "Zapisano.";
SportTypeDescription = null;
SportTypeName = null;
SportTypeId = null;
await RemoveErrorMesage(_cts.Token);
}
else
{
ErrorText = "Zapisywanie nie powidoło się. Pamiętaj, że nazwa musi być unikalna.";
await RemoveErrorMesage(_cts.Token);
}
}
private Tuple<string, string> GetImages(SportType sport )
{
var frontTile = string.Format(FrontImagePath, sport.ToString());
var backTile = string.Format(BackImagePath, sport.ToString());
return Tuple.Create(frontTile, backTile);
}
public override void OnInspectorGUI()
{
serializedObject.Update();
Item myTarget = (Item)target;
EditorGUILayout.PropertyField(state_Prop);
SportType st = (SportType)state_Prop.enumValueIndex;
switch (st)
{
case SportType.DOWNHILL:
EditorGUILayout.PropertyField(item_dh, true, new GUILayoutOption[0]);
break;
case SportType.SKELETON:
EditorGUILayout.PropertyField(item_st, true, new GUILayoutOption[0]);
break;
case SportType.SKIJUMP:
EditorGUILayout.PropertyField(item_sj, true, new GUILayoutOption[0]);
break;
}
serializedObject.ApplyModifiedProperties();
}
public void Init()
{
this.sportType = new SportType {
Id = 0, Name = "Football"
};
Team team1 = new Team {
Id = 0, Name = "Team_1", SportType = this.sportType
};
Team team2 = new Team {
Id = 1, Name = "Team_2", SportType = this.sportType
};
Team team3 = new Team {
Id = 2, Name = "Team_3", SportType = this.sportType
};
this.res1 = new Result {
Id = 0, Team = team1, Score = 3
};
this.res2 = new Result {
Id = 1, Team = team2, Score = 1
};
this.res3 = new Result {
Id = 2, Team = team3, Score = 5
};
this.sportEvent1 = new SportEvent {
Id = 0
};
this.sportEvent1.Results = new List <Result>();
this.sportEvent2 = new SportEvent {
Id = 1
};
this.sportEvent2.Results = new List <Result>();
this.sportEvent3 = new SportEvent {
Id = 2
};
this.sportEvent3.Results = new List <Result>();
DateTime date = new DateTime(2016, 11, 21, 16, 30, 0);
this.sportEvent1.Date = date;
this.sportEvent2.Date = date;
this.sportEvent3.Date = date;
this.sportEvent1.SportType = this.sportType;
this.sportEvent2.SportType = this.sportType;
this.sportEvent3.SportType = this.sportType;
this.sportEvent1.Results.Add(this.res1);
this.sportEvent1.Results.Add(this.res2);
this.sportEvent2.Results.Add(this.res1);
this.sportEvent2.Results.Add(this.res2);
this.sportEvent3.Results.Add(this.res1);
this.sportEvent3.Results.Add(this.res3);
}
public static CompetitionItemRoiRow[] GetDataForDate(DateTime fromDate, DateTime toDate, SportType sportType = SportType.Unknown, int[] competitionUniqueIDs = null, BrokerType[] brokerTypes = null)
{
var proc = new DbStoredProc()
.NotRepeatable()
.WithParam("argcompetitionmindate", fromDate)
.WithParam("argcompetitionmaxdate", toDate);
return BuildResult(proc, sportType, competitionUniqueIDs, brokerTypes);
}
public void Enum2()
{
SportType mySport = SportType.Basketball;
SportType yourSport = SportType.Football;
Console.WriteLine(mySport);
Console.WriteLine(yourSport);
}
public IList<PracticeDrillDto> ForSport(SportType sportType)
{
var results = from drill in DB.Database.Query<PracticeDrillDto, int, int>(CoachesDatabase.SportTypeDataIndex)
where drill.Index == (int)sportType
select drill.LazyValue.Value;
return results.ToList();
}
/// <summary>
/// Find daily average distance for a given sport/year
/// </summary>
/// <param name="sport"></param>
/// <param name="year"></param>
/// <returns></returns>
public decimal DailyAverage(SportType sport, int?year)
{
return(_details
.Where(a => sport == SportType.All ? true : a.Sport == sport)
.Where(a => year == null ? true : a.Date.Year == year.Value)
.Select(a => a.Distance)
.DefaultIfEmpty()
.Average());
}
/// <summary>
/// Find max sequnce for a given sport (and optionally year).
/// </summary>
/// <param name="sport"></param>
/// <param name="year"></param>
/// <returns></returns>
public int MaxSequence(SportType sport, int?year)
{
return(_details
.Where(a => sport == SportType.All ? true : a.Sport == sport)
.Where(a => year == null ? true : a.Date.Year == year.Value)
.Select(a => a.Sequence)
.DefaultIfEmpty()
.Max());
}
/// <summary>
/// Conversion from Data Access to dto Method
/// </summary>
/// <param name="d">Data Access Sport Type Object</param>
/// <returns>dto Sport Type</returns>
public static DtoSportType DataAccsessToDto(SportType d)
{
return(new DtoSportType
{
Id = d.id,
Name = d.name,
Description = d.description
});
}
public Competition(string name, string place, IEnumerable <Team> teams, DateTime startDate, SportType type, Uri liveUri)
{
Name = name;
Place = place;
StartDate = startDate;
SportType = type;
LiveUri = liveUri;
Teams = teams.ToImmutableArray();
}
/// <summary>
/// Conversion from DTO to View Model Method
/// </summary>
/// <param name="d">View Model Sport Type Object</param>
/// <returns>DTO Sport Type</returns>
public static DtoSportType ViewModelToDto(SportType d)
{
return(new DtoSportType
{
Id = d.Id,
Name = d.Name,
Description = d.Description
});
}
public static CompetitionItemRoiRow[] GetDataForNow(float minRoi = float.MinValue, SportType sportType = SportType.Unknown, int[] competitionUniqueIDs = null, BrokerType[] brokerTypes = null)
{
var proc = new DbStoredProc()
.NotRepeatable();
if (minRoi != float.MinValue) {
proc = proc
.WithParam("argroimin", minRoi);
}
return BuildResult(proc, sportType, competitionUniqueIDs, brokerTypes);
}
private void button1_Click(object sender, EventArgs e)
{
SportType selectSport = SportType.Football;
IAthlete athlete = GetAthlete(selectSport);
athlete.ChangeTeam("Chiefs");
var team = athlete.TeamName;
}
public void DeleteSecondaryTile(SportType sport, int eventId)
{
var tileParms = string.Format(EventSecondaryTileQuery, eventId, (int)sport);
var secondaryTile = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString().Contains(tileParms));
if (secondaryTile != null)
{
secondaryTile.Delete();
}
}
public void Add(SportTypeModel sporttype)
{
var sportT = new SportType
{
Title = sporttype.Title,
IsEnabled = true
};
_SportType.Add(sportT);
}
public async Task <IActionResult> Create([Bind("Name,Description")] SportType sportType)
{
if (ModelState.IsValid)
{
_context.Add(sportType);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(sportType));
}
private static SportLiveMatch CreateSportLiveMatch(SportType sport, string competition, HtmlNode item)
{
try
{
var evno = item.Attributes["evno"].Value;
var infoBlock = item.InnerHtml.GetCssNode("tbody > tr > td.td_n > a");
var link = infoBlock.Attributes["href"].Value;
var teams = CreateTeams(infoBlock);
var result = infoBlock.InnerHtml.GetCssNode("span.score").InnerText;
var slm = new SportLiveMatch
{
EventNo = evno,
SportType = sport,
Competition = competition,
Team1 = teams[0],
Team2 = teams[1],
Result = result,
};
var odds = item.InnerHtml.GetCssNodes("td").Skip(2).ToList();
slm.Win1betKey = odds[0].InnerHtml.GetCssNode("u>a").Id;
slm.Win1Odds = odds[0].InnerText;
slm.DrawbetKey = odds[1].InnerHtml.GetCssNode("u>a").Id;
slm.DrawOdds = odds[1].InnerText;
slm.Win2betKey = odds[2].InnerHtml.GetCssNode("u>a").Id;
slm.Win2Odds = odds[2].InnerText;
slm.Fora1Value = odds[3].InnerText;
slm.Fora1betKey = odds[4].InnerHtml.GetCssNode("u>a").Id;
slm.Fora1Odds = odds[4].InnerText;
slm.Fora2Value = odds[5].InnerText;
slm.Fora2betKey = odds[6].InnerHtml.GetCssNode("u>a").Id;
slm.Fora2Odds = odds[6].InnerText;
slm.TotalValue = odds[7].InnerText;
slm.TotalOverBetKey = odds[8].InnerHtml.GetCssNode("u>a").Id;
slm.TotalOverOdds = odds[8].InnerText;
slm.TotalUnderBetKey = odds[9].InnerHtml.GetCssNode("u>a").Id;
slm.TotalUnderOdds = odds[9].InnerText;
return(slm);
}
catch (Exception e)
{
}
return(null);
}
/// <summary>
/// Build one data model from a sport type view model.
/// </summary>
/// <param name="sportTypeVm">Sport type view model instance.</param>
internal SportType BuildOneDataModelFromVm(SportTypeVm sportTypeVm)
{
var result = new SportType
{
Code = sportTypeVm.Code,
Name = sportTypeVm.Name,
Description = sportTypeVm.Description
};
return(result);
}
public async Task <SportTypeViewModel> AddSportTypeAsync(SportTypeViewModel newSportType, CancellationToken ct = default(CancellationToken))
{
SportType sportType = new SportType();
sportType.Name = newSportType.Name;
sportType = await _sportTypeRepository.AddAsync(sportType, ct);
newSportType.Id = sportType.Id;
return(newSportType);
}
public static SportTypeViewModel Convert(SportType sportType)
{
SportTypeViewModel model = new SportTypeViewModel();
model.Id = sportType.Id;
model.Leagues = sportType.Leagues == null ? null : LeagueConverter.ConvertList(sportType.Leagues);
model.Name = sportType.Name;
model.Active = sportType.Active;
return(model);
}
public static ILiveResultProc GetLiveResultProc(SportType sportType)
{
switch (sportType) {
case SportType.Tennis:
return new TennisLiveResultProcessor();
case SportType.Volleyball:
return new VolleyballLiveResultProcessor();
default:
return new DefaultLiveResultProcessor();
}
}
private void Button_SubmitClicked(object sender, EventArgs e)
{
if (in_Name.Text != null)
{
SportType newSport = new SportType();
newSport.Name = in_Name.Text;
newSport.Units = units_id;
SaveAndLoad.SaveSport(newSport);
}
Application.Current.MainPage = Page;
}
public List<Fork> SearchForks(GameInfo gameInfo, List<Game> gameList, SportType sportType)
{
if (gameList == null)
{
throw new ArgumentNullException(nameof(gameList));
}
var rulesList = this.rulesProvider.GiveListOfRules(sportType);
var listForks = new List<Fork>();
for (var i = 0; i < gameList.Count; i++)
{
for (var j = i + 1; j < gameList.Count; j++)
{
foreach (var rule in rulesList)
{
var firstGame = gameList[i];
var secondGame = gameList[j];
var profitRate = rule.CalculateProfitRate(firstGame, secondGame);
if (profitRate == -1)
{
continue;
}
var fork = new Fork
{
SportType = sportType,
FirstGame = firstGame,
SecondGame = secondGame,
ProfitRate = profitRate,
FirstBetsName = firstGame.BetsName,
SecondBetsName = secondGame.BetsName,
DetectedTime = DateTime.Now
};
foreach (var firstBet in rule.FirstGameCoefTypes)
{
fork.CoefsOfFirstBets.Add(firstBet, firstGame.Coefficients[firstBet]);
}
foreach (var secondBet in rule.SecondGameCoefTypes)
{
fork.CoefsOfSecondBets.Add(secondBet, secondGame.Coefficients[secondBet]);
}
listForks.Add(fork);
}
}
}
return listForks;
}
private List<Fork> GetForks(SportType sportType, Dictionary<GameInfo, List<Game>> gameLists)
{
var forks = new List<Fork>();
for (var i = 0; i < gameLists.Count; i++)
{
forks.AddRange(this.Searcher.SearchForks(
gameLists.ElementAt(i).Key,
gameLists.ElementAt(i).Value,
sportType));
}
return forks;
}
public Dictionary<GameInfo, List<Game>> ParseExtendedGames(SportType type, List<GameInfo> gamesInfo)
{
var gamesAllBets = new Dictionary<SportType, List<Game>>();
Parallel.ForEach(this.parsers,
parser =>
{
var games = parser.ParseExtendedCoefficients(gamesInfo, type);
if (gamesAllBets.ContainsKey(type))
{
gamesAllBets[type].AddRange(games);
}
else
{
gamesAllBets.Add(type, games.ToList());
}
});
return this.grouper.GroupGamesByGameInfo(gamesAllBets).Values.Single();
}
public void CreateEventTile( SportType sport, EventType eventType, int eventId, DateTime eventDateTime, string fieldName, string teamName, string opponentName = "" )
{
var tileParms = string.Format(EventSecondaryTileQuery, eventId, (int)sport);
var tileUri = string.Format("/Views/Events/{0}EventLandingPage.xaml?{1}",eventType.ToString(), tileParms);
var tileImages = GetImages(sport);
var frontTitle = GetTitle(eventType, teamName, opponentName);
var backTitle = GetBackTitle(eventDateTime);
DeleteSecondaryTile(sport, eventId);
var newTileData = new StandardTileData
{
BackgroundImage = new Uri(tileImages.Item1, UriKind.RelativeOrAbsolute),
Title = frontTitle,
BackTitle = backTitle,
BackContent = fieldName,
BackBackgroundImage = new Uri(tileImages.Item2, UriKind.RelativeOrAbsolute)
};
ShellTile.Create(new Uri(tileUri, UriKind.RelativeOrAbsolute), newTileData);
}
public static FullResult BuildResultFromString(SportType sportType, string resString)
{
FullResult result ;
switch (sportType) {
case SportType.Tennis:
case SportType.Volleyball:
var buildTennisResult = BuildFullResult(resString);
if (buildTennisResult.SubResult.Count == 1) {
var tempTennisResult = new FullResult {
CompetitorResultOne = 0,
CompetitorResultTwo = 0
};
tempTennisResult.SubResult.Add(new SimpleResult {
CompetitorResultOne = buildTennisResult.CompetitorResultOne,
CompetitorResultTwo = buildTennisResult.CompetitorResultTwo
});
tempTennisResult.SubResult.AddRange(buildTennisResult.SubResult);
buildTennisResult = tempTennisResult;
}
result = buildTennisResult;
break;
case SportType.IceHockey:
result = BuildFullResult(resString);
break;
case SportType.Basketball:
result = BuildFullResult(resString);
break;
case SportType.Football:
result = BuildFullResult(resString);
break;
default:
result = BuildFullResult(resString);
break;
}
return result;
}
public Workout(string Name, SportType sport_type, Steps[] steps)
{
this.Name = Name;
this.SportType = SportType;
this.Steps = new List<Steps>(steps);
}
public static RawTemplateObj<CompetitionSpecifyTransport> CreateCompetitionSpecifyRawObject(int rawID, int parentRawID, ICompetitionSpecify competitionSpecify, LanguageType language, SportType sportType, GenderType genderDetected)
{
var result = new RawTemplateObj<CompetitionSpecifyTransport>();
result.RawObject.ID = rawID;
result.RawObject.ParentID = parentRawID;
result.Object.LanguageType = language;
result.Object.SportType = sportType;
result.Object.GenderType = genderDetected;
result.Object.CompetitionUniqueID = competitionSpecify.CompetitionuniqueID;
result.Object.ID = competitionSpecify.CompetitionSpecifyUniqueID;
return result;
}
private static RawCompetitionSpecify GetRawCompetitionSpecifyInt(BrokerType brokerType, LanguageType language,
SportType sportType, GenderType genderDetected, string[] nameOrigin)
{
return RawCompetitionSpecify.DataSource.FilterByBroker(brokerType).FilterByLanguage(language).FilterBySportType(sportType)
.FilterByNameCompetition(nameOrigin)
.FilterByGender(genderDetected,
RawCompetitionSpecify.Fields.CompetitionuniqueID,
RawCompetitionSpecify.Fields.CompetitionspecifyuniqueID,
RawCompetitionSpecify.Fields.Name,
RawCompetitionSpecify.Fields.ID,
RawCompetitionSpecify.Fields.RawCompetitionID)
.FirstOrDefault();
}
public List<Rule> GiveListOfRules(SportType sportType)
{
var rawRules = this.Text.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
return rawRules.Select(ParseRule).ToList();
}
public static RawCompetitionSpecify CreateCompetitionSpecify(ProcessStat competitionStat, BrokerType brokerType, LanguageType language, SportType sportType, GenderType genderDetected, string[] nameOrigin, CompetitionParsed competitionToSave, GatherBehaviorMode algoMode)
{
var nameOriginShort = CompetitionHelper.GetShortCompetitionName(nameOrigin, sportType);
var competitionRaw = new BrokerEntityBuilder<RawCompetition>(competitionStat)
.SetupValidateObject(rawCompetition => rawCompetition.CompetitionuniqueID != default(int))
.SetupGetRaw(() => {
return RawCompetition.DataSource.FilterByBroker(brokerType).FilterByLanguage(language).FilterBySportType(sportType)
.FilterByNameCompetition(nameOriginShort)
.FilterByGender(genderDetected, RawCompetition.Fields.CompetitionuniqueID, RawCompetition.Fields.Linkstatus).FirstOrDefault();
})
.SetupCreateRaw(() => BrokerEntityIfaceCreator.CreateEntity<RawCompetition>(brokerType, language, sportType, genderDetected, LinkEntityStatus.Unlinked, nameOriginShort))
.SetupCreateOriginal(algoMode, rawCompetition => {
var competition = Competition.DataSource.FilterByLanguage(language).FilterBySportType(sportType)
.FilterByNameCompetition(nameOriginShort)
.FilterByGender(genderDetected, Competition.Fields.CompetitionuniqueID)
.FirstOrDefault();
if (competition == null) {
var competitionUnique = new CompetitionUnique {
IsUsed = true
};
competitionUnique.Save();
competition = new Competition {
Datecreatedutc = DateTime.UtcNow,
Languagetype = language,
SportType = sportType,
Name = CompetitionHelper.ListStringToName(nameOriginShort),
Gendertype = genderDetected,
CompetitionuniqueID = competitionUnique.ID
};
competition.Save();
}
rawCompetition.CompetitionuniqueID = competition.CompetitionuniqueID;
rawCompetition.Linkstatus = LinkEntityStatus.Original | LinkEntityStatus.Linked;
return rawCompetition;
})
.SetupFinally(rawCompetition => {
if (algoMode.HasFlag(GatherBehaviorMode.CreateNewLanguageName)) {
if (rawCompetition.CompetitionuniqueID != default(int) && !Competition.DataSource
.WhereEquals(Competition.Fields.CompetitionuniqueID, rawCompetition.CompetitionuniqueID)
.FilterByLanguage(language)
.IsExists()) {
new Competition {
CompetitionuniqueID = rawCompetition.CompetitionuniqueID,
Datecreatedutc = DateTime.UtcNow,
Gendertype = genderDetected,
SportType = sportType,
Name = CompetitionHelper.ListStringToName(nameOriginShort),
Languagetype = language
}.Save();
}
}
rawCompetition.Save();
return rawCompetition;
})
.MakeObject();
return BrokerEntityIfaceCreator.CreateEntity<RawCompetitionSpecify>(brokerType, language, sportType, genderDetected, LinkEntityStatus.Unlinked, nameOrigin, specify => {
specify.RawCompetitionID = competitionRaw.ID;
if (specify.CompetitionuniqueID == default(int) && competitionRaw.CompetitionuniqueID != default(int)) {
specify.CompetitionuniqueID = competitionRaw.CompetitionuniqueID;
}
});
}
public RawCompetitorSpecifyKey(BrokerType brokerType, LanguageType language, SportType sportType,
GenderType genderDetected, string[] nameOrigin)
{
BrokerType = brokerType;
Language = language;
SportType = sportType;
GenderDetected = genderDetected;
NameOrigin = nameOrigin;
}
public RawTemplateObj<CompetitionSpecifyTransport> GetCompetitionSpecify(ProcessStat competitionStat, ProcessStat competitionSpecifyStat, BrokerType brokerType, LanguageType language, SportType sportType, string[] nameOrigin, CompetitionParsed competitionToSave, GatherBehaviorMode algoMode)
{
return InvokeSafeSingleCall(() => {
var genderDetected = GenderDetectorHelper.Instance[nameOrigin];
if (genderDetected == GenderType.Unknown) {
_logger.Error("{0}: {1}", nameOrigin, genderDetected);
}
nameOrigin = CleanCompetitionName(nameOrigin);
var rawCompetitionSpecify = new BrokerEntityBuilder<RawCompetitionSpecify>(competitionSpecifyStat)
.SetupValidateObject(specify => true/*NOTE!! && specify.CompetitionSpecifyUniqueID != default(int)*/)
.SetupGetRaw(() => RawCompetitionHelper.GetRawCompetitionSpecify[new RawCompetitionHelper.RawCompetitorSpecifyKey(brokerType, language, sportType, genderDetected, nameOrigin)])
.SetupCreateRaw(() => RawCompetitionHelper.CreateCompetitionSpecify(competitionStat, brokerType, language, sportType, genderDetected, nameOrigin, competitionToSave, algoMode))
.SetupCreateOriginal(algoMode, specify => {
if (specify.CompetitionSpecifyUniqueID == default(int)) {
var competitionSpecifyUnique = new CompetitionSpecifyUnique {
CompetitionuniqueID = specify.CompetitionuniqueID
};
competitionSpecifyUnique.Save();
specify.CompetitionSpecifyUniqueID = competitionSpecifyUnique.ID;
specify.Save();
}
var competitionSpecify = new CompetitionSpecify {
Datecreatedutc = DateTime.UtcNow,
Languagetype = language,
SportType = sportType,
Name = CompetitionHelper.ListStringToName(nameOrigin),
Gendertype = genderDetected,
CompetitionuniqueID = specify.CompetitionuniqueID
};
specify.CompetitionSpecifyUniqueID = competitionSpecify.CompetitionSpecifyUniqueID;
if (competitionSpecify.CompetitionuniqueID != specify.CompetitionuniqueID) {
_logger.Error("{0} != {1}. {2}. SKIP", competitionSpecify.CompetitionuniqueID, specify.CompetitionuniqueID, CompetitionHelper.ListStringToName(nameOrigin));
return null;
}
specify.Linkstatus = LinkEntityStatus.Original | LinkEntityStatus.Linked;
return specify;
})
.SetupFinally(specify => {
if (specify.CompetitionSpecifyUniqueID != default(int)) {
if (algoMode.HasFlag(GatherBehaviorMode.CreateNewLanguageName)) {
if (specify.CompetitionSpecifyUniqueID != default(int) &&
specify.CompetitionuniqueID != default(int) && !CompetitionSpecify.DataSource
.WhereEquals(CompetitionSpecify.Fields.CompetitionSpecifyUniqueID, specify.CompetitionSpecifyUniqueID)
.FilterByLanguage(language)
.IsExists()) {
new CompetitionSpecify {
Languagetype = language,
Name = CompetitionHelper.ListStringToName(nameOrigin),
CompetitionSpecifyUniqueID = specify.CompetitionSpecifyUniqueID,
CompetitionuniqueID = specify.CompetitionuniqueID,
Datecreatedutc = DateTime.UtcNow,
Gendertype = genderDetected,
SportType = sportType
}.Save();
}
}
}
specify.Save();
return specify;
})
.MakeObject();
return RawCompetitionHelper.CreateCompetitionSpecifyRawObject(rawCompetitionSpecify.ID, rawCompetitionSpecify.RawCompetitionID, rawCompetitionSpecify, language, sportType, genderDetected);
}, new RawTemplateObj<CompetitionSpecifyTransport>());
}
public MatchParsed(SportType sportType)
{
SportType = sportType;
Odds = new List<OddParsed>();
}
public static string[] GetShortCompetitionName(string[] names, SportType sportType)
{
var result = new List<string>();
for (var i = 0; i < names.Length; i++) {
var name = names[i];
if (sportType != SportType.Tennis && _stopListWithGetNext.Any(slw => name.IndexOf(slw, StringComparison.InvariantCultureIgnoreCase) >= 0)) {
result.Add(name);
var nextIdx = i + 1;
if (nextIdx < names.Length) {
result.Add(names[nextIdx]);
}
break;
}
if (_stopListWithIncludeCurrent.Any(slw => name.IndexOf(slw, StringComparison.InvariantCultureIgnoreCase) >= 0)) {
result.Add(name);
break;
}
if (_stopListWithExcludeCurrent.Any(sl => name.IndexOf(sl, StringComparison.InvariantCultureIgnoreCase) >= 0) && result.Count > 0) {
break;
}
result.Add(name);
}
return result.ToArray();
}
public RawTemplateObj<CompetitorParsedTransport> GetCompetitor(ProcessStat competitorStat, BrokerType brokerType, LanguageType languageType, SportType sportType, GenderType genderType, string[] names, GatherBehaviorMode algoMode)
{
return InvokeSafeSingleCall(() => {
names = names
.Where(name => !string.IsNullOrWhiteSpace(name))
.Select(name => {
var indexOf = name.IndexOf("(", StringComparison.InvariantCultureIgnoreCase);
var cleanedName = (indexOf > 0 ? name.Substring(0, indexOf) : name).Trim(_trimChars);
return cleanedName.RemoveDiacritics();
})
.Where(name => !string.IsNullOrWhiteSpace(name))
.ToArray();
if (!names.Any()) {
throw new Exception("nameFull.IsNullOrWhiteSpace() && nameShort.IsNullOrWhiteSpace()");
}
var competitors = new BrokerEntityBuilder<List<RawCompetitor>>(competitorStat)
.SetupValidateObject(competitorsRaw => competitorsRaw.SafeAny() && competitorsRaw.All(c => c.CompetitoruniqueID != default(int)))
.SetupGetRaw(() => RawCompetitorHelper.GetRawCompetitor[new RawCompetitorHelper.RawCompetitorCacheKey(brokerType, languageType, sportType, genderType, names)])
.SetupCreateOriginal(algoMode, list => {
var uniqueID = new CompetitorUnique {
IsUsed = true
};
uniqueID.Save();
var competitor = new Competitor {
CompetitoruniqueID = uniqueID.ID,
SportType = sportType,
Datecreatedutc = DateTime.UtcNow,
Languagetype = languageType,
Name = names[0],
Gendertype = genderType
};
competitor.Save();
list.Each(el => el.Linkstatus = LinkEntityStatus.Original | LinkEntityStatus.Linked);
return list;
})
.SetupFinally(list => {
var firstElement = list.First();
if (algoMode.HasFlag(GatherBehaviorMode.CreateNewLanguageName) && firstElement.CompetitoruniqueID != default(int) && !Competitor.DataSource
.WhereEquals(Competitor.Fields.CompetitoruniqueID, firstElement.CompetitoruniqueID)
.WhereEquals(Competitor.Fields.Languagetype, (short)languageType)
.IsExists()) {
new Competitor {
CompetitoruniqueID = firstElement.CompetitoruniqueID,
SportType = sportType,
Datecreatedutc = DateTime.UtcNow,
Languagetype = languageType,
Name = names[0],
Gendertype = genderType
}.Save();
}
list.Each(el => el.Save());
return list;
})
.MakeObject();
return competitors.Any()
? competitors.Select(c => new RawTemplateObj<CompetitorParsedTransport> {
RawObject = {
ID = c.ID
},
Object = {
LanguageType = languageType,
SportType = sportType,
GenderType = genderType,
ID = c.CompetitoruniqueID
}
}).First()
: new RawTemplateObj<CompetitorParsedTransport>();
}, new RawTemplateObj<CompetitorParsedTransport>());
}
public RawCompetitorCacheKey(BrokerType brokerType, LanguageType languageType, SportType sportType, GenderType genderType, string[] names)
{
BrokerType = brokerType;
LanguageType = languageType;
SportType = sportType;
GenderType = genderType;
Names = names;
}
public CompetitionParsed(string[] competitionName, SportType sportType = SportType.Unknown)
{
Name = competitionName;
Type = sportType != SportType.Unknown ? sportType : SportTypeHelper.Instance[competitionName];
Matches = new List<MatchParsed>();
}
public Activity(SportType sport, DateTime startTime, TimeSpan duration)
{
SportType = sport;
StartTime = startTime;
Duration = duration;
}