public TeamMatchEvent(int team, bool isCpt, int mult, MatchEvent ev)
: base(ev)
{
teamId = team;
isCaptain = isCpt;
multiplier = mult;
}
public void ComboMatchesEvents_EqualCards()
{
// Ensure two yellow cards are matched
var events = new MatchEvent[]
{
// Two yellow cards
new MatchEvent {
Id = 11, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 8
},
new MatchEvent {
Id = 12, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 20
},
};
// Two yellow cards generate a red card
var combo = new AutoSanctionCardConfig {
Card1Type = 1, Card2Type = 1, Penalty = new PenaltyConfig {
Type1 = 2
}
};
var result = AutoSanctionDispatcher.ComboAppliesToMatchEvents(combo, events, out MatchEvent ev1, out MatchEvent ev2);
Assert.IsTrue(result);
}
public void ComboMatchesEvents_InverseMatch()
{
// Ensure blue + yellow matches yellow + blue combo
var events = new MatchEvent[]
{
// Blue + yellow
new MatchEvent {
Id = 11, IdMatch = 1001, Type = (int)MatchEventType.Card3, IdPlayer = 101, MatchMinute = 8
},
new MatchEvent {
Id = 12, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 20
},
};
// Yellow + Blue generate red card
var combo = new AutoSanctionCardConfig {
Card1Type = 1, Card2Type = 3, Penalty = new PenaltyConfig {
Type1 = 2
}
};
var result = AutoSanctionDispatcher.ComboAppliesToMatchEvents(combo, events, out MatchEvent ev1, out MatchEvent ev2);
Assert.IsTrue(result);
}
public void ComboMatchesEvents_Negative1()
{
// Ensure blue + yellow doesn't match yellow + yellow
var events = new MatchEvent[]
{
new MatchEvent {
Id = 11, IdMatch = 1001, Type = (int)MatchEventType.Card3, IdPlayer = 101, MatchMinute = 8
},
new MatchEvent {
Id = 12, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 20
},
};
// Yellow + Yellow generate red card
var combo = new AutoSanctionCardConfig {
Card1Type = 1, Card2Type = 1, Penalty = new PenaltyConfig {
Type1 = 2
}
};
var result = AutoSanctionDispatcher.ComboAppliesToMatchEvents(combo, events, out MatchEvent ev1, out MatchEvent ev2);
Assert.IsFalse(result);
}
public long AddMatchEvent(MatchEvent matchEvent)
{
using (var c = DbFactory.Get())
{
return(c.Insert <MatchEvent>(matchEvent));
}
}
public void ComboMatchesEvents_Larger()
{
// Ensure yellow, yellow, blue, yellow matches blue alone
var events = new MatchEvent[]
{
new MatchEvent {
Id = 11, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 8
},
new MatchEvent {
Id = 12, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 20
},
new MatchEvent {
Id = 11, IdMatch = 1001, Type = (int)MatchEventType.Card3, IdPlayer = 101, MatchMinute = 8
},
new MatchEvent {
Id = 12, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 20
},
};
// Blue alone generates red card
var combo = new AutoSanctionCardConfig {
Card1Type = 3, Card2Type = 0, Penalty = new PenaltyConfig {
Type1 = 2
}
};
var result = AutoSanctionDispatcher.ComboAppliesToMatchEvents(combo, events, out MatchEvent ev1, out MatchEvent ev2);
Assert.IsTrue(result);
}
public bool basicEquals(MatchEvent other)
{
return(type == other.type &&
footballerId == other.footballerId &&
pointDifference == other.pointDifference &&
number == other.number);
}
public void GroupPlayerEvents22()
{
var events = new MatchEvent[]
{
new MatchEvent {
Id = 11, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 8
},
new MatchEvent {
Id = 12, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 20
},
new MatchEvent {
Id = 13, IdMatch = 1001, Type = (int)MatchEventType.Card3, IdPlayer = 102, MatchMinute = 20
},
new MatchEvent {
Id = 14, IdMatch = 1001, Type = (int)MatchEventType.Card2, IdPlayer = 102, MatchMinute = 30
},
};
var result = AutoSanctionDispatcher.GroupPlayerEvents(events);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(2, result[101].Count);
Assert.AreEqual(2, result[102].Count);
Assert.AreEqual(events[0], result[101][0]);
Assert.AreEqual(events[1], result[101][1]);
Assert.AreEqual(events[2], result[102][0]);
Assert.AreEqual(events[3], result[102][1]);
}
public MatchEvent CreateMatchEvent(int minute, Event @event, Match match, Team team)
{
var matchEvent = new MatchEvent {
Event = @event, Minute = minute, Team = team
};
//hmm, checking on description is not the best approach
if (@event.Description.Equals("Goal"))
{
if (match.HomeTeam == team)
{
match.HomeGoals += 1;
}
else
{
match.AwayGoals += 1;
}
_logger.LogInformation($"{minute} - {@event.Description} {matchEvent.Team}! {match.Score}");
}
else
{
//red card decrease strength??
_logger.LogInformation($"{minute} - {@event.Description} {matchEvent.Team}");
}
return(matchEvent);
}
public void ComboMatchesEvents_Single()
{
var events = new MatchEvent[]
{
// Two yellow cards
new MatchEvent {
Id = 11, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 8
},
new MatchEvent {
Id = 12, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 20
},
new MatchEvent {
Id = 13, IdMatch = 1001, Type = (int)MatchEventType.Card3, IdPlayer = 101, MatchMinute = 20
},
new MatchEvent {
Id = 14, IdMatch = 1001, Type = (int)MatchEventType.Card2, IdPlayer = 101, MatchMinute = 30
},
};
var combos = new AutoSanctionCardConfig[]
{
new AutoSanctionCardConfig {
Card1Type = 1, Card2Type = 1, Penalty = new PenaltyConfig {
Type1 = 2
}
},
};
var result = AutoSanctionDispatcher.GetCardCombosForMatchEvents(combos, events);
Assert.AreEqual(1, result.Count());
Assert.AreEqual(combos[0], result[0]);
}
public static Entities.MatchEvent ToEntity(this MatchEvent matchEvent) =>
new Entities.MatchEvent()
{
UserId = matchEvent.UserId.Value,
MatchId = matchEvent.MatchId.Value,
EventTime = matchEvent.EventTime,
MatchEventType = (int)matchEvent.MatchEventType
};
public MatchStatsDetailPage(MatchEvent matchEvent)
{
this.MatchEvent = matchEvent;
InitializeComponent();
NavigationPage.SetHasNavigationBar(this, true);
}
protected void rptEvents_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
MatchEventDTO ev = e.Item.DataItem as MatchEventDTO;
MatchEvent meControl = e.Item.FindControl("me") as MatchEvent;
meControl.Player1 = ev.Player1;
meControl.Player2 = ev.Player2;
}
private static EventData ConvertToEventData(FootballGameEntity gameEntity, MatchEvent @event)
{
return(new EventData
{
FootballGameId = gameEntity.Id,
SerializedEvent = JsonConvert.SerializeObject(@event),
Type = @event.GetType().FullName
});
}
public void CopyDTOToDbObject(MatchEvent dbObj)
{
dbObj.Match_Id = Match_Id;
dbObj.MatchEvent_Id = MatchEvent_Id;
dbObj.Event_Cd = Event_Cd;
dbObj.Player1_Id = Player1_Id;
dbObj.Player2_Id = Player2_Id;
dbObj.EventFlags = EventFlags;
dbObj.Minute = Minute;
}
public MatchEvent(MatchEvent other)
{
dateTime = other.dateTime;
type = other.type;
typeString = other.typeString;
footballerId = other.footballerId;
footballerName = other.footballerName;
pointDifference = other.pointDifference;
number = other.number;
}
public void GroupPlayerEvents_Empty()
{
var events = new MatchEvent[]
{
};
var result = AutoSanctionDispatcher.GroupPlayerEvents(events);
Assert.AreEqual(0, result.Count);
}
private Tweet FindMatchingTweet(TweetMatcher matcher, MatchEvent matchEvent)
{
var tweets = matcher.Find(matchEvent);
var selectedTweet = tweets
.Except(_elements.Select(e => e.Tweet))
.OrderByDescending(t => t.Popularity)
.LastOrDefault();
return(selectedTweet ?? Tweet.Null);
}
protected override void OnBindingContextChanged()
{
base.OnBindingContextChanged();
MatchEvent matchEvent = this.BindingContext as MatchEvent;
Team homeTeam = matchEvent.HomeTeam;
Team guestTeam = matchEvent.GuestTeam;
homeTeamImage.Source = ImageSource.FromResource(homeTeam.Icon, typeof(MatchOverviewPage).GetTypeInfo().Assembly);
guestTeamImage.Source = ImageSource.FromResource(guestTeam.Icon, typeof(MatchOverviewPage).GetTypeInfo().Assembly);
}
private static BinaryExpression GetExpression(MatchEvent criteria, ParameterExpression p)
{
var streamNameMatches = Expression.Equal(
Expression.Property(p, "StreamName"),
Expression.Constant(criteria.StreamName));
var typeMatches = Expression.Equal(
Expression.Property(p, "Type"),
Expression.Constant(criteria.Type));
return(Expression.AndAlso(streamNameMatches, typeMatches));
}
public int Insert(MatchEvent matchEvent)
{
return(Add(INSERT, new Dictionary <string, object>
{
{ "matchId", matchEvent.MatchId },
{ "teamId", matchEvent.TeamId },
{ "minute", matchEvent.Minute },
{ "playerId", matchEvent.PlayerId },
{ "eventType", matchEvent.EventType }
}));
}
public void GetCardComboNewCards_OnlyLast()
{
// Several events already happened to same player, yellow arrives.
// Check that a new event is returned with a red card, and only that.
var events = new MatchEvent[]
{
new MatchEvent {
Id = 11, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 8
},
new MatchEvent {
Id = 12, IdMatch = 1001, Type = (int)MatchEventType.Card3, IdPlayer = 101, MatchMinute = 8
},
new MatchEvent {
Id = 13, IdMatch = 1001, Type = (int)MatchEventType.Card4, IdPlayer = 101, MatchMinute = 8
},
new MatchEvent {
Id = 14, IdMatch = 1001, Type = (int)MatchEventType.Card5, IdPlayer = 101, MatchMinute = 8
},
new MatchEvent {
Id = 15, IdMatch = 1001, Type = (int)MatchEventType.Card1, IdPlayer = 101, MatchMinute = 30
}
};
var combos = new AutoSanctionCardConfig[]
{
new AutoSanctionCardConfig {
Card1Type = 1, Card2Type = 1, Penalty = new PenaltyConfig {
Type1 = 2
}, AddYellowCards = 0
},
new AutoSanctionCardConfig {
Card1Type = 3, Card2Type = 0, Penalty = new PenaltyConfig {
Type1 = 5
}
},
};
var newEvent = events[4];
var result = AutoSanctionDispatcher.GetCardCombosNewCards(events, combos, newEvent);
Assert.AreEqual(2, result.Count());
var resultEvents = result.ToList();
Assert.AreEqual((int)MatchEventType.Card2, resultEvents[0].Type);
var ev2 = resultEvents[1];
Assert.AreEqual((int)MatchEventType.AddToPdrData1, ev2.Type);
Assert.AreEqual(-2, ev2.IntData1);
}
public IEnumerable <Tweet> Find(MatchEvent @event)
{
var range = TimeSpan.FromMinutes(5);
var startRange = _footballGame.MatchStart
.Add(@event.When)
.Add(_delta);
var endRange = startRange.Add(range);
return(_tweets
.Where(t => t.Date < endRange && t.Date > startRange));
}
public Boolean sendMessage()
{
try
{
MatchEventKey key = new MatchEventKey();
key.MatchId = 1;
List <Attributes> attributes = new List <Attributes>();
attributes.Add(Attributes.Blocked);
attributes.Add(Attributes.BigChance);
MatchEvent value = new MatchEvent();
value.Operation = Operation.Add;
value.EventId = 12345;
value.MatchId = 1;
value.PhaseId = Phase.a2;
value.Type = Type.Assist;
value.Attributes = attributes;
value.TeamFromId = 564;
value.TeamToId = 458;
value.PlayerFromId = 10756;
value.PlayerToId = 15783;
value.TimeUTC = "2018-09-12T06:55:59.919";
value.Minute = 45;
value.Second = 13;
value.InjuryMinute = 44;
value.PositionX = 0.541211f;
value.PositionY = 0.342281f;
value.GoalGatePositionX = 0.144251f;
value.GoalGatePositionY = 0.264641f;
value.GoalGatePositionZ = 0.0f;
Console.WriteLine(value.ToString());
Message <MatchEventKey, MatchEvent> message = new Message <MatchEventKey, MatchEvent>();
message.Key = key;
message.Value = value;
Task <DeliveryReport <MatchEventKey, MatchEvent> > task = producer.ProduceAsync(topicName, message);
task.Wait();
if (task.IsCompleted)
{
return(true);
}
}
catch (Exception e)
{
Console.WriteLine("Error while sending message to topic", e);
return(false);
}
return(false);
}
private void UpdateMatchEvent(MatchEvent matchEvent, MatchEventPersonViewModel viewModel)
{
if (viewModel.PersonPrimaryKey != matchEvent.PersonPrimaryKey ||
viewModel.MatchEventInRunningType.ToMatchEventType() != matchEvent.MatchEventType ||
viewModel.Minute != matchEvent.Minute ||
viewModel.Extra != matchEvent.Extra)
{
matchEvent.PersonPrimaryKey = (Guid)viewModel.PersonPrimaryKey;
matchEvent.MatchEventType = (MatchEventType)viewModel.MatchEventInRunningType.ToMatchEventType();
matchEvent.Minute = viewModel.Minute;
matchEvent.Extra = viewModel.Extra;
}
}
public MatchEventDTO ConvertDBObjectToDTO(MatchEvent dbObj)
{
return(new MatchEventDTO
{
Match_Id = dbObj.Match_Id,
MatchEvent_Id = dbObj.MatchEvent_Id,
EventFlags = dbObj.EventFlags,
Event_Cd = dbObj.Event_Cd,
Player2_Id = dbObj.Player2_Id,
Player1_Id = dbObj.Player1_Id,
Minute = dbObj.Minute
});
}
public static MatchEvent New(string matchId, EventType eventOccurred, TeamId teamIndex, string team1, string team2, int?playerId)
{
var matchEvent = new MatchEvent
{
MatchId = matchId,
Action = eventOccurred.ToString(),
TeamId = (int)teamIndex,
Team1 = team1,
Team2 = team2,
PlayerId = playerId
};
return(matchEvent);
}
public void AddMatchEvent(MatchEvent matchEvent)
{
var newMatchEvent = new MatchEvent
{
EventMinute = matchEvent.EventMinute,
IsForHomeTeam = matchEvent.IsForHomeTeam,
MatchId = matchEvent.Match.MatchId,
PlayerId = matchEvent.Player?.PlayerId,
EventType = matchEvent.EventType
};
_context.MatchEvents.Add(newMatchEvent);
_context.SaveChanges();
}
public static IEnumerable <long> CreateMatchEvents(IDbConnection c, IDbTransaction t, IEnumerable <MatchEvent> events)
{
var result = new List <long>();
if (events != null)
{
foreach (var ev in events)
{
var(_, me) = MatchEvent.Create(c, t, ev);
result.Add(me.Id);
}
}
return(result);
}
private static async Task CreateEvent(IDbConnection c, IDbTransaction t, Match dbMatch, List <MatchEvent> events, Models.Db.Team team, Models.Db.Player player, MatchEventType type, int minuteOffset)
{
var ev = new MatchEvent
{
IdDay = dbMatch.IdDay,
IdMatch = dbMatch.Id,
IdTeam = (team != null ? team.Id : 0),
IdPlayer = (player != null ? player.Id : 0),
MatchMinute = new Random().Next(0 + minuteOffset, 45 + minuteOffset),
Type = (int)type,
};
ev.Id = await c.InsertAsync(ev, t);
events.Add(ev);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExclusiveEventStoreCatchupQuery"/> class.
/// </summary>
/// <param name="dbContext">The event store database context to execute the query against.</param>
/// <param name="lockResourceName">Name of the lock. Multiple instances compete with other instances having the same <paramref name="lockResourceName" />.</param>
/// <param name="getStartAtId">The id of the first event to query.</param>
/// <param name="matchEvents">Specifies the event types to include the query. If none are specified, all events are queried.</param>
public ExclusiveEventStoreCatchupQuery(EventStoreDbContext dbContext, string lockResourceName, Func<long> getStartAtId, MatchEvent[] matchEvents)
{
this.dbContext = dbContext;
this.lockResourceName = lockResourceName;
if (TryGetAppLock())
{
startAtId = getStartAtId();
IQueryable<StorableEvent> eventQuery = dbContext.Events;
matchEvents = matchEvents ?? new[] { new MatchEvent() };
// if specific event types are requested, we can optimize the event store query
// if Event or IEvent are requested, we don't filter -- this requires reading every event
if (matchEvents.Any())
{
var eventTypes = matchEvents.Select(m => m.Type).Distinct().ToArray();
var aggregates = matchEvents.Select(m => m.StreamName).Distinct().ToArray();
if (!aggregates.Contains(MatchEvent.Wildcard))
{
var aggregateWildCard = aggregates.Any(string.IsNullOrWhiteSpace) ||
aggregates.Contains(MatchEvent.Wildcard);
var eventWildCard = eventTypes.Any(string.IsNullOrWhiteSpace) ||
eventTypes.Contains(MatchEvent.Wildcard);
eventQuery = eventQuery.Where(e => (aggregateWildCard || aggregates.Contains(e.StreamName)) &&
(eventWildCard || eventTypes.Contains(e.Type)));
}
}
this.eventQuery = eventQuery;
expectedNumberOfEvents = eventQuery.Count(e => e.Id >= startAtId);
events = DurableStreamFrom(eventQuery, startAtId);
}
else
{
events = Enumerable.Empty<StorableEvent>();
}
}
private static void ProcessEvents(Match match, HattrickDataMatch htMatch)
{
foreach (var htMatchEvent in htMatch.EventList)
{
MatchEvent matchEvent = new MatchEvent();
matchEvent.EventIndex = short.Parse(htMatchEvent.Index);
matchEvent.EventText = htMatchEvent.EventText;
matchEvent.EventTypeID = short.Parse(htMatchEvent.EventTypeID);
matchEvent.EventVariation = short.Parse(htMatchEvent.EventVariation);
matchEvent.Minute = short.Parse(htMatchEvent.Minute);
matchEvent.ObjectPlayerID = string.IsNullOrEmpty(htMatchEvent.ObjectPlayerID) ? (int?)null : int.Parse(htMatchEvent.ObjectPlayerID);
matchEvent.SubjectPlayerID = string.IsNullOrEmpty(htMatchEvent.SubjectPlayerID) ? (int?)null : int.Parse(htMatchEvent.SubjectPlayerID);
matchEvent.SubjectTeamID = string.IsNullOrEmpty(htMatchEvent.SubjectTeamID) ? (int?)null : int.Parse(htMatchEvent.SubjectTeamID);
match.AddMatchEvent(matchEvent);
}
}
private void MakeEvent(MatchEvent ev)
{
if (MatchEvent != null)
{
MatchEvent(ev);
}
}
