public void AddStartSpawnPoint(Vector3 Point, TeamNames Team)
{
StartSpawnPT SpawnPoint = new StartSpawnPT();
SpawnPoint.Point = Point;
SpawnPoint.Team = Team;
}
// no default constructor
public Team(TeamNames team)
{
m_TeamName = team;
// get string version of team name
switch (m_TeamName)
{
case TeamNames.Red:
m_TeamNameString = "Red";
break;
case TeamNames.Blue:
m_TeamNameString = "Blue";
break;
case TeamNames.Yellow:
m_TeamNameString = "Yellow";
break;
case TeamNames.Green:
m_TeamNameString = "Green";
break;
}
// get score label GUI object using team name
m_ScoreText = GameObject.Find(m_TeamNameString).GetComponent <Text>();
m_ScoreText.text = m_TeamNameString + ": 0";
}
public void SetFormFieldsToUpdate()
{
this.ButtonContent = "Update";
this.SubmitFormCommand = new DelegateCommand(this.UpdateEmployeeDetails);
this.FormHeader = "Edit Employee";
SelectedEmployee = new Employee()
{
ID = CurrentEmployee.ID,
FirstName = CurrentEmployee.FirstName,
LastName = CurrentEmployee.LastName,
BirthDate = CurrentEmployee.BirthDate,
JoiningDate = CurrentEmployee.JoiningDate,
Mobile = CurrentEmployee.Mobile,
Skype = CurrentEmployee.Skype,
Team = CurrentEmployee.Team,
Department = CurrentEmployee.Department,
Gender = CurrentEmployee.Gender,
Address = CurrentEmployee.Address,
ProfessionalSummary = CurrentEmployee.ProfessionalSummary,
Salary = CurrentEmployee.Salary,
Image = CurrentEmployee.Image,
Email = CurrentEmployee.Email
};
SelectedEmployee.Team = TeamNames.Single(m => m == SelectedEmployee.Team);
SelectedEmployee.Department = Departments.Single(m => m.ID == SelectedEmployee.Department.ID);
}
public StartSpawnPT FindStartSpawnPoint(Entity player)
{
string sessionteam = player.GetField <string>("sessionteam");
TeamNames Team = GetTeamByTeamString(sessionteam);
return(FindStartSpawnPoint(Team));
}
public Developer(string firstName, string lastName, int idNumber, bool isPluralSightLicensed, TeamNames memberOfTeam)
{
FirstName = firstName;
LastName = lastName;
IdNumber = idNumber;
IsPluralSightLicensed = isPluralSightLicensed;
MemberOfTeam = memberOfTeam;
}
public void AddStartSpawnPoint(float x, float y, float z, TeamNames Team)
{
Vector3 Point = new Vector3(x, y, z);
StartSpawnPT SpawnPoint = new StartSpawnPT();
SpawnPoint.Point = Point;
SpawnPoint.Team = Team;
}
public IEnumerable <EventRuleElement> GetRulesMatch(string collection, IEnumerable <EventRuleElement> eventRules)
{
var rules = eventRules.Where(r => collection.IsMatchOrNoPattern(r.TeamProjectCollection) &&
ProjectName.IsMatchOrNoPattern(r.TeamProject) &&
TeamNames.IsMatchOrNoPattern(r.TeamName) &&
RepoName.IsMatchOrNoPattern(r.GitRepository));
return(rules);
}
public IEnumerable <EventRuleElement> GetRulesMatch(string collection, IEnumerable <EventRuleElement> eventRules)
{
var rules = eventRules.Where(r => r.Events.HasFlag(TfsEvents.ReleaseCreated) &&
collection.IsMatchOrNoPattern(r.TeamProjectCollection) &&
ProjectName.IsMatchOrNoPattern(r.TeamProject) &&
TeamNames.IsMatchOrNoPattern(r.TeamName) &&
ReleaseDefinition.IsMatchOrNoPattern(r.ReleaseDefinition));
return(rules);
}
public override EventRuleElement GetRuleMatch(string collection, IEnumerable <EventRuleElement> eventRules)
{
var rule = eventRules.FirstOrDefault(r => r.Events.HasFlag(TfsEvents.RepositoryCreated) &&
collection.IsMatchOrNoPattern(r.TeamProjectCollection) &&
ProjectName.IsMatchOrNoPattern(r.TeamProject) &&
TeamNames.IsMatchOrNoPattern(r.TeamName) &&
RepoName.IsMatchOrNoPattern(r.GitRepository));
return(rule);
}
public ItemId[][] RecommendedItemTable = new ItemId[Enum.GetValues(typeof(ItemRecommendations)).Length][]; // table of recommended items for the hero
public Hero(string name, TeamNames team)
{
Name = name;
Team = team;
// fill in the table of recommended item purchases based on data in the xml file
// these are the recmmendations displayed in the store UI for each hero in game
// GetRecommendedItems();
InitHero();
}
public override EventRuleElement GetRuleMatch(string collection, Configuration.EventRuleCollection eventRules)
{
var rule = eventRules.FirstOrDefault(r => r.Events.HasFlag(TfsEvents.PullRequestStatusUpdate) &&
collection.IsMatchOrNoPattern(r.TeamProjectCollection) &&
ProjectName.IsMatchOrNoPattern(r.TeamProject) &&
TeamNames.IsMatchOrNoPattern(r.TeamName) &&
RepoName.IsMatchOrNoPattern(r.GitRepository));
return(rule);
}
public override EventRuleElement GetRuleMatch(string collection, IEnumerable <EventRuleElement> eventRules)
{
var rule = eventRules.FirstOrDefault(r => r.Events.HasFlag(TfsEvents.Checkin) &&
collection.IsMatchOrNoPattern(r.TeamProjectCollection) &&
Projects.Keys.IsMatchOrNoPattern(r.TeamProject) &&
TeamNames.IsMatchOrNoPattern(r.TeamName) &&
SubmittedItems.IsMatchOrNoPattern(r.SourcePath));
return(rule);
}
public override EventRuleElement GetRuleMatch(string collection, Configuration.EventRuleCollection eventRules)
{
var rule = eventRules.FirstOrDefault(r => r.Events.HasFlag(TfsEvents.BuildQualityChanged) &&
(r.BuildStatuses & BuildStatus) != 0 &&
collection.IsMatchOrNoPattern(r.TeamProjectCollection) &&
ProjectName.IsMatchOrNoPattern(r.TeamProject) &&
TeamNames.IsMatchOrNoPattern(r.TeamName) &&
BuildDefinition.IsMatchOrNoPattern(r.BuildDefinition));
return(rule);
}
public override EventRuleElement GetRuleMatch(string collection, IEnumerable <EventRuleElement> eventRules)
{
var rule = eventRules.FirstOrDefault(r => r.Events.HasFlag(TfsEvents.BuildCompleted) &&
(r.BuildStatuses & BuildStatus) != 0 &&
collection.IsMatchOrNoPattern(r.TeamProjectCollection) &&
ProjectName.IsMatchOrNoPattern(r.TeamProject) &&
TeamNames.IsMatchOrNoPattern(r.TeamName) &&
BuildDefinition.IsMatchOrNoPattern(r.BuildDefinition));
return(rule);
}
public override EventRuleElement GetRuleMatch(string collection, IEnumerable <EventRuleElement> eventRules)
{
var rule = eventRules.FirstOrDefault(r => r.Events.HasFlag(TfsEvents.ChangesetComment) &&
collection.IsMatchOrNoPattern(r.TeamProjectCollection) &&
ProjectName.IsMatchOrNoPattern(r.TeamProject) &&
TeamNames.IsMatchOrNoPattern(r.TeamName) &&
SourcePath.IsMatchOrNoPattern(r.SourcePath) &&
Comment.IsMatchOrNoPattern(r.Text));
return(rule);
}
private Uri GetTeamUrl(TeamNames teamName)
{
switch (teamName)
{
case TeamNames.Customer:
return(new Uri(string.Format(TeamUrl, teamCutomerIdentifier)));
default:
throw new NotImplementedException(string.Format("The URL for the team name '{0}' has not been implemented yet. Please add"));
}
}
public override EventRuleElement GetRuleMatch(string collection, IEnumerable <EventRuleElement> eventRules)
{
var rule = eventRules.FirstOrDefault(r =>
r.Events.HasFlag(TfsEvents.WorkItemComment) &&
collection.IsMatchOrNoPattern(r.TeamProjectCollection) &&
ProjectName.IsMatchOrNoPattern(r.TeamProject) &&
TeamNames.IsMatchOrNoPattern(r.TeamName) &&
WiType.IsMatchOrNoPattern(r.WorkItemType) &&
AreaPath.IsMatchOrNoPattern(r.AreaPath));
return(rule);
}
public override EventRuleElement GetRuleMatch(string collection, IEnumerable <EventRuleElement> eventRules)
{
var rule = eventRules.FirstOrDefault(r =>
(r.Events.HasFlag(TfsEvents.WorkItemCreated) && IsNew ||
r.Events.HasFlag(TfsEvents.WorkItemChanged) && IsChangedFieldMatchOrNotSet(ChangedFields, r.WorkItemFieldItems)) &&
collection.IsMatchOrNoPattern(r.TeamProjectCollection) &&
ProjectName.IsMatchOrNoPattern(r.TeamProject) &&
TeamNames.IsMatchOrNoPattern(r.TeamName) &&
WiType.IsMatchOrNoPattern(r.WorkItemType) &&
AreaPath.IsMatchOrNoPattern(r.AreaPath));
return(rule);
}
public Store(TeamNames team)
{
Team = team;
// currently there are only 5 items with limited stock in the game
Inventory = new Item[InventorySize];
//fred
/*
* Inventory[0] = new Item(ItemId.gem);
* Inventory[1] = new Item(ItemId.ward_observer);
* Inventory[2] = new Item(ItemId.courier);
* Inventory[3] = new Item(ItemId.flying_courier);
* Inventory[4] = new Item(ItemId.smoke_of_deceit);
*/
}
public async Task <IEnumerable <ISearchResult> > SearchTeams(string searchText, DateTime viewDate)
{
var teamGroups = await TeamNames
.Where(w => w.Description.Contains(searchText.Trim()) && w.TeamV.IsActive)
.Select(s => s.TeamV)
.GroupBy(g => g.HeaderKey).ToListAsync();
var teamVs = new List <TeamV>();
foreach (var teamGroup in teamGroups)
{
teamVs.Add(teamGroup.OrderByDescending(t => t.EffectiveFrom).First());
}
return(teamVs.ToViewModels(viewDate).Cast <ISearchResult>());
}
protected override void ProcessRecord()
{
//TraceControlSettings.TraceLevel = System.Diagnostics.SourceLevels.All;
//TraceControlSettings.AddTraceListener(new TextWriterTraceListener("XrmTooling.txt"));
try
{
var service = ConnectToCrm();
WriteDebug("Instantiating logic...");
var logic = new ExportLogic(service);
WriteDebug("Retrieving teams...");
var teams = logic.RetrieveTeams();
if (ExportAll.IsPresent)
{
WriteDebug("Exporting ALL teams...");
logic.Export(FileName, teams);
}
else if (TeamNames != null && TeamNames.Length > 0)
{
WriteDebug("Exporting teams: " + string.Join(", ", TeamNames));
logic.Export(FileName, teams.Where(t => TeamNames.Contains(t.Name)));
}
else if (TeamIds != null && TeamIds.Length > 0)
{
WriteDebug("Exporting teams with Ids: " + string.Join(", ", TeamIds));
logic.Export(FileName, teams.Where(t => TeamIds.Contains(t.TeamId)));
}
else
{
throw new ArgumentException("Encountered unexpected combination of arguments. Please review documentation and try again.");
}
}
catch (Exception ex)
{
ThrowTerminatingError(new ErrorRecord(ex, ex.GetType().Name, ErrorCategory.NotSpecified, null));
}
}
// TODO: check for nodes if they've even been found
public override bool ParseInfo()
{
var strStatus = node.SelectSingleNode("//div[@class='match_logos']/div[@class='score']/div").InnerText;
if (strStatus == "offen")
{
Status = AnalyzerConstants.MatchStatus.NotPlayed;
return(true);
}
// fetch team names
var teamNameNodes = node.SelectNodes("//div[@class='match_names']/div[@class='team']/a");
TeamNames.Add(AnalyzerConstants.TeamSide.A, teamNameNodes[0].InnerText.Trim());
TeamNames.Add(AnalyzerConstants.TeamSide.B, teamNameNodes[1].InnerText.Trim());
// fetch map score
var teamScoreNodes = node.SelectNodes("//div[@class='match_logos']/div[@class='score']/span");
Score.Add(AnalyzerConstants.TeamSide.A, Convert.ToInt32(teamScoreNodes[0].InnerText));
Score.Add(AnalyzerConstants.TeamSide.B, Convert.ToInt32(teamScoreNodes[1].InnerText));
// was the match actually played or is this a nasty defwin?
var resultsNode = node.SelectSingleNode("//div[@id='content']/h2[2]");
if (resultsNode.InnerText != "Ergebnisse")
{
Status = AnalyzerConstants.MatchStatus.DefWin;
return(true);
}
Status = AnalyzerConstants.MatchStatus.Played;
// get round score per map
var nodeFirstMapScore = node.SelectSingleNode("//div[@id='content']/text()[preceding-sibling::br]");
var firstMapScoreStr = nodeFirstMapScore.InnerText.Trim().Split(':');
if (firstMapScoreStr.Count() != 3)
{
ErrorHandling.Log($"Unexpected Error: Could not find map score for match { url }");
return(false);
}
// first map
var firstMapScores = new Dictionary <AnalyzerConstants.TeamSide, int>();
var firstMapName = firstMapScoreStr[0];
var firstMapScoreA = Convert.ToInt32(firstMapScoreStr[1].Trim());
var firstMapScoreB = Convert.ToInt32(firstMapScoreStr[2].Trim());
firstMapScores.Add(AnalyzerConstants.TeamSide.A, firstMapScoreA);
firstMapScores.Add(AnalyzerConstants.TeamSide.B, firstMapScoreB);
Maps.Add(new Map(firstMapName, firstMapScores));
// second map
var secondMapScores = new Dictionary <AnalyzerConstants.TeamSide, int>();
var secondMapScoreStr = nodeFirstMapScore.NextSibling.NextSibling.InnerText.Trim().Split(':');
var secondMapName = secondMapScoreStr[0];
var secondMapScoreA = Convert.ToInt32(secondMapScoreStr[1].Trim());
var secondMapScoreB = Convert.ToInt32(secondMapScoreStr[2].Trim());
secondMapScores.Add(AnalyzerConstants.TeamSide.A, secondMapScoreA);
secondMapScores.Add(AnalyzerConstants.TeamSide.B, secondMapScoreB);
Maps.Add(new Map(secondMapName, secondMapScores));
// if map score is not available anymore, but round scores are availabe
if (Score.All(s => s.Value == 0))
{
// Team A
Score[AnalyzerConstants.TeamSide.A] = firstMapScoreA > firstMapScoreB ? 1 : 0;
Score[AnalyzerConstants.TeamSide.A] += secondMapScoreA > secondMapScoreB ? 1 : 0;
// Team B
Score[AnalyzerConstants.TeamSide.B] = firstMapScoreB > firstMapScoreA ? 1 : 0;
Score[AnalyzerConstants.TeamSide.B] += secondMapScoreB > secondMapScoreA ? 1 : 0;
}
// get vote data from match log
var logNode = node.SelectSingleNode("//table[@id='match_log']");
var trNodes = logNode.SelectNodes("tr");
var voteDataFound = false;
foreach (var tr in trNodes)
{
if (voteDataFound)
{
break;
}
var cols = tr.SelectNodes("td");
if (cols == null || cols.Count == 0)
{
continue;
}
var aktion = cols[2].InnerText; // 3rd column: "Aktion"
if (aktion != "mapvote_ended")
{
continue;
}
var voteData = cols[3].InnerText.Split(',');
var voteDateStr = cols[0].SelectSingleNode("span").GetAttributeValue("title", "");
DateTime voteDate = DateTime.MinValue;
if (!string.IsNullOrEmpty(voteDateStr))
{
voteDate = DateTime.Parse(voteDateStr);
}
foreach (var sVote in voteData)
{
if (sVote == "timeouted")
{
Status = AnalyzerConstants.MatchStatus.DefWin;
break;
}
var RegExMatch = System.Text.RegularExpressions.Regex.Match(sVote.Trim(), AnalyzerConstants.MapvotePattern);
var validateLogEntry = RegExMatch.Success && RegExMatch.Groups.Count > 1; // First group is always the whole string
if (!validateLogEntry)
{
ErrorHandling.Log($"Could not read mapvote entry: \"{ sVote }\"");
continue;
}
// get captured groups
var reSide = RegExMatch.Groups[1].Value;
var reType = RegExMatch.Groups[2].Value;
var reMap = RegExMatch.Groups[3].Value;
// interpret groups
AnalyzerConstants.TeamSide side = AnalyzerConstants.TeamSide.Unknown;
if (reSide == "T1")
{
side = AnalyzerConstants.TeamSide.A;
}
else if (reSide == "T2")
{
side = AnalyzerConstants.TeamSide.B;
}
else
{
ErrorHandling.Log($"Could not read voting team: \"{ reSide }\"");
}
AnalyzerConstants.VoteType type = AnalyzerConstants.VoteType.Unknown;
if (reType == "bans")
{
type = AnalyzerConstants.VoteType.Ban;
}
else if (reType == "picks")
{
type = AnalyzerConstants.VoteType.Pick;
}
else
{
ErrorHandling.Log($"Could not read voting type: \"{ reType }\"");
}
var map = new Map(reMap);
if (type == AnalyzerConstants.VoteType.Pick)
{
map = Maps.Where(m => m.Name == map.Name).First();
}
// create vote instance
Vote vote;
if (voteDate != DateTime.MinValue)
{
vote = new Vote(side, type, map, voteDate);
}
else
{
vote = new Vote(side, type, map);
}
Votes.Add(vote);
}
voteDataFound = true;
}
if (!voteDataFound)
{
ErrorHandling.Log($"Could not find vote data for presumably played match { url }. This may happen if the match has no match log entries anymore.");
return(false);
}
return(true);
}
public StartSpawnPT FindStartSpawnPoint(string Team)
{
TeamNames TeamB = GetTeamByTeamString(Team);
return(FindStartSpawnPoint(TeamB));
}
public void UpdateScore(TeamNames teamNo)
{
m_Teams[(int)teamNo].AddScore();
}
public void SetTeam(TeamNames newTeam)
{
m_Team = newTeam;
}
private static IList <Player> GetPlayers(IEnumerable <Player> allPlayers, TeamNames teamName)
{
return(allPlayers.Where(x => x.TeamNames.Contains(teamName)).ToList());
}
public string GetProjectTeamName(int teamId)
{
TeamNames.TryGetValue(teamId, out var teamName);
return(teamName ?? "");
}
public async Task <IEnumerable <string> > GetTeamAutoCompleteList(Guid userId, bool isAdmin, string searchText)
{
var teams = await TeamNames.Where(w => w.Description.Contains(searchText.Trim()) && w.TeamV.IsActive).ToListAsync();
return(teams.Select(s => s.Description).Distinct().OrderBy(o => o));
}
private void AddPlayers(List <Player> players, CookieContainer cookieContainer, TeamNames teamName)
{
var htmlDocument = GetHtmlDocument(cookieContainer, GetTeamUrl(teamName));
var teamCustomerplayers = htmlDocument.DocumentNode.Descendants().Where
(x => (x.Attributes["class"] != null &&
x.Attributes["class"].Value.Contains("p-name"))).Select(x =>
new Player(x.InnerHtml.Split(',')[0], x.InnerHtml.Split(',').Count() == 1 ? Identifiers.InitialNotFound.ToString() : x.InnerHtml.Split(',')[1].Trim())
{
TeamNames = new List <TeamNames> {
teamName
}
}).Skip(11).ToList();
var telegraphComparer = new TelegraphPlayerComparer();
for (int i = teamCustomerplayers.Count - 1; i >= 0; i--)
{
if (players.Contains(teamCustomerplayers[i], telegraphComparer))
{
var player = players.Single(x => telegraphComparer.Equals(x, teamCustomerplayers[i]));
player.TeamNames.Add(teamName);
teamCustomerplayers.Remove(teamCustomerplayers[i]);
}
}
players.AddRange(teamCustomerplayers);
}
public StartSpawnPT FindStartSpawnPoint(TeamNames Team)
{
return(new StartSpawnPT());
}
