/// <summary>
/// Creates new Scrum Team and initialize Planning Poker game.
/// </summary>
/// <param name="teamName">Name of the team.</param>
/// <param name="scrumMasterName">Name of Scrum Master.</param>
/// <param name="deck">Selected deck of estimation cards to use in the team.</param>
/// <returns><c>True</c> if the operation was successful; otherwise <c>false</c>.</returns>
public async Task <bool> CreateTeam(string teamName, string scrumMasterName, Deck deck)
{
if (string.IsNullOrEmpty(teamName) || string.IsNullOrEmpty(scrumMasterName))
{
return(false);
}
try
{
TeamResult teamResult = null;
using (_busyIndicatorService.Show())
{
teamResult = await _planningPokerService.CreateTeam(teamName, scrumMasterName, deck, CancellationToken.None);
}
if (teamResult != null)
{
await _planningPokerInitializer.InitializeTeam(teamResult, scrumMasterName);
ControllerHelper.OpenPlanningPokerPage(_navigationManager, teamResult.ScrumTeam, scrumMasterName);
return(true);
}
}
catch (PlanningPokerException ex)
{
var message = ControllerHelper.GetErrorMessage(ex);
await _messageBoxService.ShowMessage(message, Resources.MessagePanel_Error);
}
return(false);
}
private static TeamResult GetTeamResult(Race race, Team team)
{
var retVal = new TeamResult
{
TeamNumber = team.Number,
TeamName = team.Name,
Category = team.Category,
NumberOfStages = 0,
TotalValue = 0,
EndTime = team.FinishTime,
NumberOfPoints = 0,
StageResults = new List <StageResult>()
};
foreach (var stage in race.Stages)
{
StageResult stageResult = GetStageResult(team, stage);
var numberOfPointsToCompleteStage = stage.MimimumPointsToCompleteStage ?? race.MinimumPointsToCompleteStage;
if (stageResult.NumberOfPoints >= numberOfPointsToCompleteStage)
{
retVal.NumberOfStages += 1;
retVal.TotalValue += stageResult.TotalValue;
retVal.NumberOfPoints += stageResult.NumberOfPoints;
}
retVal.StageResults.Add(stageResult);
}
SettleFinishTime(race, team, retVal);
retVal.StageResults = retVal.StageResults.OrderBy(stage => stage.StageNumber).ToList();
return(retVal);
}
public static List <string> Generate(string conferenceName, string divisionName, string teamName, League league)
{
List <string> ret = new List <string>();
Team team = league.FindTeam(teamName);
GameList games = league.AllGames.FilterByTeams(new List <int> {
team.Id
});
TeamResult results = games.Results[team.Id];
ret.Add("Records:");
ret.Add($"Overall: {results.OverallRecord}");
ret.Add($"Conference: {results.ConferenceRecord}");
ret.Add($"Division: {results.DivisionRecord}");
ret.Add(string.Empty);
/*
* Cross-Conference win/loss
* Division chances
* Rankings
* PF/PA
*/
return(ret);
}
/// <summary>
/// Creates a CSV file on the user's desktop (overwriting any existing file).
/// This will simply list each work item if the items are flat, or it will
/// list all the children of the items along with the title of the parent if
/// the items are hierarchical.
/// </summary>
public static void ExportItems(string queryName, TeamResult result)
{
var path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
path = Path.Combine(path, $"{queryName}.csv");
Console.Write($"Exporting to {path}");
using (var file = new StreamWriter(path)) {
if (result.QueryType == QueryType.Tree)
{
// these are hierarchical, so list each child and include the
// title of its parent
foreach (var parent in result.Items)
{
foreach (var child in parent.Items)
{
Console.Write(".");
EmitItem(file, parent, child);
}
}
}
else
{
// these are flat, so just list each item
foreach (var item in result.Items)
{
Console.Write(".");
EmitItem(file, null, item);
}
}
}
Console.WriteLine("done");
}
private static void SettleFinishTime(Race race, Team team, TeamResult retVal)
{
if (team.FinishTime.HasValue)
{
switch (race.RaceType)
{
case RaceType.Classic:
retVal.RaceDuration = team.FinishTime.Value - race.StartTime.Value;
break;
case RaceType.TimeLimit:
SetRaceRurationForNonClassic(team, retVal);
break;
case RaceType.NoTimeLimit:
SetRaceRurationForNonClassic(team, retVal);
break;
default:
throw new Exception($"Unknown raceid {race.RaceId}");
}
if ((race.RaceType == RaceType.Classic || race.RaceType == RaceType.TimeLimit) && race.MaxDuration.HasValue)
{
var difference = retVal.RaceDuration - race.MaxDuration.Value;
if (difference.TotalSeconds > 0)
{
retVal.TotalValue -= (int)Math.Ceiling(difference.TotalMinutes) * race.PenaltyPerMinuteLate.Value;
}
}
}
}
/// <summary>
/// Convert XML string into TeamResult object
/// </summary>
/// <param name="response">xml string</param>
/// <returns></returns>
public static TeamResult ParseTeamResult(string response)
{
TeamResult t = new TeamResult();
t.Teams = new Dictionary <string, string>();
try
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(response);
foreach (XmlNode xmlNode in xmlDoc.ChildNodes[1].ChildNodes)
{
switch (xmlNode.Name)
{
case "IsSuccesfull": t.IsSuccesfull = bool.Parse(xmlNode.InnerText); break;
case "ReturnValue":
foreach (XmlNode presetNode in xmlNode.ChildNodes)
{
t.Teams.Add(presetNode.Attributes["Id"].Value, presetNode.Attributes["Name"].Value);
}
break;
}
}
xmlDoc = null;
}
catch (Exception ex)
{
Common.Logger.Create().Error(ex.ToString());
}
return(t);
}
public GameOverDialogTeams(List <SongFinished> results)
{
TeamResults = new List <TeamResult>();
results.ForEach(x =>
{
var teamResult = TeamResults.FirstOrDefault(y => y.Team.Id == x.User.Team.Id);
//If there's no team in the results list for the current player
if (teamResult == null)
{
teamResult = new TeamResult()
{
Team = (x.User as Player).Team,
Players = new List <Player>()
};
TeamResults.Add(teamResult);
}
x.User.Score = x.Score;
teamResult.Players.Add(x.User);
teamResult.TotalScore += x.Score;
});
TeamResults = TeamResults.OrderByDescending(x => x.TotalScore).ToList();
DataContext = this;
InitializeComponent();
}
/// <summary>
/// Downloads the work items for the query. This supports both flat
/// queries and hierarchical. For hierarchical, this will retrieve the
/// top two levels of the hierarchy of the query, which must be of type
/// "Tree of work items" with a tree type of "Parent/Child".
/// </summary>
public TeamResult RunQuery(string folderName, string queryName)
{
Console.WriteLine($"Running {folderName}/{queryName}");
// create instance of VssConnection using Personal Access Token
var connection = new VssConnection(new Uri(_collectionUrl), new VssBasicCredential(string.Empty, _personalAccessToken));
// get the client instance
var witClient = connection.GetClient <WorkItemTrackingHttpClient>();
// get 2 levels of the query hierarchy items
var queryHierarchyItems = witClient.GetQueriesAsync(_projectName, depth: 2).Result;
// holders for our return value
TeamResult teamResult = null;
// find the folder we're looking for
var queriesFolder = queryHierarchyItems.FirstOrDefault(qhi => qhi.Name.Equals(folderName));
if (queriesFolder != null)
{
// find the query we're looking for
QueryHierarchyItem query = null;
if (queriesFolder.Children != null)
{
query = queriesFolder.Children.FirstOrDefault(qhi => qhi.Name.Equals(queryName));
}
var result = witClient.QueryByIdAsync(query.Id).Result;
Console.Write($"Retrieving results ({result.QueryType} query)");
List <TeamItem> items = null;
switch (result.QueryType)
{
case QueryType.Tree:
items = ProcessHierarchyItems(result, witClient);
break;
case QueryType.Flat:
items = ProcessFlatItems(result, witClient);
break;
case QueryType.OneHop:
throw new NotImplementedException($"{nameof(QueryType.OneHop)} not supported");
}
teamResult = new TeamResult
{
Items = items,
QueryType = result.QueryType
};
}
Console.WriteLine("done");
return(teamResult);
}
private static void SetRaceRurationForNonClassic(Team team, TeamResult retVal)
{
var firstVisitedPoint = team.VisitedPoints.OrderBy(t => t.Time).FirstOrDefault();
if (firstVisitedPoint != null)
{
retVal.RaceDuration = team.FinishTime.Value - firstVisitedPoint.Time;
}
}
private async void EventTeamsListView_ItemSelected(object sender, SelectedItemChangedEventArgs args)
{
TeamResult item = (TeamResult)args.SelectedItem;
if (item == null)
{
return;
}
App.currTeamNumber = item.TeamNumber;
App.currTeamName = item.Name;
Team itemTeam = viewModel.DataStoreTeam.GetItemByKeyAsync(item.TeamNumber.ToString()).Result;
await Navigation.PushAsync(new TeamDetailsPage(App.currFRCEventKey, itemTeam));
}
internal static async Task <string> SetToBegain(TeamResult team, int roomIndex)
{
var msg = Newtonsoft.Json.JsonConvert.SerializeObject(new CommonClass.TeamBegain()
{
c = "TeamBegain",
TeamNum = team.TeamNumber,
RoomIndex = roomIndex
// TeamNumber = team.TeamNumber
});
var result = await Startup.sendInmationToUrlAndGetRes($"{teamUrl}", msg);
return(result);
}
private static CreateTeamController CreateController(
IPlanningPokerInitializer planningPokerInitializer = null,
IPlanningPokerClient planningPokerService = null,
IMessageBoxService messageBoxService = null,
IBusyIndicatorService busyIndicatorService = null,
INavigationManager navigationManager = null,
TeamResult teamResult = null,
string errorMessage = null)
{
if (planningPokerInitializer == null)
{
var planningPokerInitializerMock = new Mock <IPlanningPokerInitializer>();
planningPokerInitializer = planningPokerInitializerMock.Object;
}
if (planningPokerService == null)
{
var planningPokerServiceMock = new Mock <IPlanningPokerClient>();
var createSetup = planningPokerServiceMock.Setup(o => o.CreateTeam(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Deck>(), It.IsAny <CancellationToken>()));
if (errorMessage == null)
{
createSetup.ReturnsAsync(teamResult);
}
else
{
createSetup.ThrowsAsync(new PlanningPokerException(errorMessage));
}
planningPokerService = planningPokerServiceMock.Object;
}
if (messageBoxService == null)
{
var messageBoxServiceMock = new Mock <IMessageBoxService>();
messageBoxService = messageBoxServiceMock.Object;
}
if (busyIndicatorService == null)
{
var busyIndicatorServiceMock = new Mock <IBusyIndicatorService>();
busyIndicatorService = busyIndicatorServiceMock.Object;
}
if (navigationManager == null)
{
var navigationManagerMock = new Mock <INavigationManager>();
navigationManager = navigationManagerMock.Object;
}
return(new CreateTeamController(planningPokerService, planningPokerInitializer, messageBoxService, busyIndicatorService, navigationManager));
}
public TeamViewModel(TeamResult model)
{
Name = model.Country;
FifaCode = model.FifaCode;
MatchesPlayed = model.GamesPlayed;
MatchesWon = model.Wins;
MatchesLost = model.Losses;
MatchesDraw = model.Draws;
GoalsScored = model.GoalsFor;
GoalsTaken = model.GoalsAgainst;
GoalsDifference = model.GoalDifferential;
}
private void AddTeamOutcome(string team, Outcome outcome)
{
TeamResult teamResult;
if (this.teams.TryGetValue(team, out teamResult))
{
teamResult.AddOutcome(outcome);
}
else
{
teamResult = new TeamResult();
teamResult.AddOutcome(outcome);
this.teams.Add(team, teamResult);
}
}
private void SetLabels()
{
TeamResult myRep = teamResults.Find(x => x.FifaCode == App.lastTeam.FifaCode);
lbNaziv.Content = $"{App.LocalizedString("Naziv")}: {myRep.Country}";
lbFifaCode.Content = $"{App.LocalizedString("Fifakod")}: {myRep.FifaCode}";
lbGamesPlayed.Content = $"{App.LocalizedString("GamesPlayed")}: {myRep.GamesPlayed}";
lbGamesWon.Content = $"{App.LocalizedString("GamesWon")}: {myRep.Wins}";
lbGamesLost.Content = $"{App.LocalizedString("GamesLost")}: {myRep.Losses}";
lbGamesUndecided.Content = $"{App.LocalizedString("GamedTied")}: {myRep.Draws}";
lbGoalsScored.Content = $"{App.LocalizedString("GoalsScored")}: {myRep.GoalsFor}";
lbGoalsTaken.Content = $"{App.LocalizedString("GoalsTaken")}: {myRep.GoalsAgainst}";
lbDiff.Content = $"{App.LocalizedString("GoalsDiff")}: {myRep.GoalDifferential}";
btSettings.Content = App.LocalizedString("Settings");
this.Title = App.LocalizedString("RepOverview");
}
/// <summary>
/// Joins existing Scrum Team and initialize Planning Poker game.
/// </summary>
/// <param name="teamName">Name of the team.</param>
/// <param name="memberName">Name of the joining member.</param>
/// <param name="asObserver"><c>True</c> if member is joining as observer only; otherwise <c>false</c>.</param>
/// <returns><c>True</c> if the operation was successful; otherwise <c>false</c>.</returns>
public async Task <bool> JoinTeam(string teamName, string memberName, bool asObserver)
{
if (string.IsNullOrEmpty(teamName) || string.IsNullOrEmpty(memberName))
{
return(false);
}
try
{
TeamResult teamResult = null;
using (_busyIndicatorService.Show())
{
teamResult = await _planningPokerService.JoinTeam(teamName, memberName, asObserver, CancellationToken.None);
}
if (teamResult != null)
{
await _planningPokerInitializer.InitializeTeam(teamResult, memberName);
ControllerHelper.OpenPlanningPokerPage(_navigationManager, teamResult.ScrumTeam, memberName);
return(true);
}
}
catch (PlanningPokerException ex)
{
var message = ex.Message;
if (message.IndexOf(MemberExistsError1, StringComparison.OrdinalIgnoreCase) >= 0 &&
message.IndexOf(MemberExistsError2, StringComparison.OrdinalIgnoreCase) >= 0)
{
message = ControllerHelper.GetErrorMessage(ex);
message = $"{message}{Environment.NewLine}{Resources.JoinTeam_ReconnectMessage}";
if (await _messageBoxService.ShowMessage(message, Resources.JoinTeam_ReconnectTitle, Resources.JoinTeam_ReconnectButton))
{
return(await ReconnectTeam(teamName, memberName, false, CancellationToken.None));
}
}
else
{
message = ControllerHelper.GetErrorMessage(ex);
await _messageBoxService.ShowMessage(message, Resources.MessagePanel_Error);
}
}
return(false);
}
public TeamResult SummariseTeamResult(Championship cmp, FootballTeam team)
{
if (cmp == null || team == null)
{
return(null);
}
var result = new TeamResult()
{
Championship = cmp,
Team = team
};
_context.SimulatorData <Competition>()
.Where(el => el.FirstTeamId == team.Id && el.ChampionshipId == cmp.Id).ToList()
.ForEach((el) =>
{
if (el.FirstTeamScore.HasValue)
{
result.Scored += el.FirstTeamScore ?? 0;
result.Conceded += el.SecondTeamScore ?? 0;
result.Won += el.FirstTeamScore > el.SecondTeamScore ? 1 : 0;
result.Lost += el.FirstTeamScore < el.SecondTeamScore ? 1 : 0;
result.Draw += el.FirstTeamScore == el.SecondTeamScore ? 1 : 0;
}
}
);
_context.SimulatorData <Competition>()
.Where(el => el.SecondTeamId == team.Id && el.ChampionshipId == cmp.Id).ToList()
.ForEach((el) =>
{
if (el.FirstTeamScore.HasValue)
{
result.Scored += el.SecondTeamScore ?? 0;
result.Conceded += el.FirstTeamScore ?? 0;
result.Lost += el.FirstTeamScore > el.SecondTeamScore ? 1 : 0;
result.Won += el.FirstTeamScore < el.SecondTeamScore ? 1 : 0;
result.Draw += el.FirstTeamScore == el.SecondTeamScore ? 1 : 0;
}
}
);
result.Points = 3 * result.Won + result.Draw;
return(result);
}
public static IList <TeamResult> GetTeamResults(IList <Finisher> finishers)
{
// ==== TEAMS ====
var teamResults = new List <TeamResult>();
var allTeamMembers = new List <Finisher>(); // Tracks finishers in a team, so can't count as part of a club team.
var teams = GetTeamNames(finishers);
foreach (var team in teams)
{
var teamFinishers = GetFinishersInTeam(finishers, team);
allTeamMembers.AddRange(teamFinishers);
var teamResult = new TeamResult
{
Name = team,
// Get the TEAM_SIZE team members with lowest score.
Members = teamFinishers.OrderBy(f => f.Position).Take(TEAM_SIZE).ToList(),
};
teamResult.CalcScore();
teamResults.Add(teamResult);
}
// ==== CLUBS ====
var clubTeamFinishers = finishers.Where(f => !allTeamMembers.Contains(f)).ToList();
var clubs = GetClubTeamNames(clubTeamFinishers);
foreach (var club in clubs)
{
var clubFinishers = GetFinishersInClub(clubTeamFinishers, club);
var clubTeamResult = new TeamResult
{
Name = club,
// Get the TEAM_SIZE team members with lowest score.
Members = clubFinishers.OrderBy(f => f.Position).Take(TEAM_SIZE).ToList(),
};
clubTeamResult.CalcScore();
teamResults.Add(clubTeamResult);
}
return(teamResults);
}
public void ExecuteLoadEventTeamsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
TeamResults.Clear();
var teams = DataStoreTeam.GetItemsAsync(true).Result;
foreach (var team in teams)
{
TeamDetailViewModel matchViewModel = new TeamDetailViewModel(App.currFRCEventKey, team);
TeamResult teamResult = new TeamResult();
teamResult.TeamNumber = team.TeamNumber;
teamResult.Name = team.Name;
teamResult.TotalRP = matchViewModel.TotalRP;
teamResult.TotalScore = matchViewModel.TotalScore;
teamResult.AverageScore = matchViewModel.AverageScore;
teamResult.TotalPowercells = matchViewModel.TotalPowercells;
teamResult.AveragePowercells = matchViewModel.AveragePowercells;
teamResult.TotalBroken = matchViewModel.TotalBroken;
TeamResults.Add(teamResult);
}
}
catch (Exception ex)
{
Title = ex.Message;
}
finally
{
IsBusy = false;
}
}
private TeamResult GetTeamResult(int teamID, int leagueID)
{
var dataCache = new DataCache();
var team = TeamsService.GetInstance().GetTeam(teamID, leagueID, dataCache: dataCache);
var teams = TeamsService.GetInstance().GetTeams(leagueID: team.LeagueID, showAll: true, dataCache: dataCache);
var players = PlayersService.GetInstance().GetPlayers(dataCache: dataCache);
var playerStats = StatsService.GetInstance().GetAllStats(teamID, team.SportID, leagueID, dataCache: dataCache);
var statTypes = GamesService.GetInstance().GetStatTypes(team.SportID).OrderBy(s => s.GridDisplayOrder);
var teamResult = new TeamResult()
{
ID = team.ID,
Name = team.Name,
Games = team.Games.Select(g => new TeamGameResult()
{
ID = g.ID,
GameDate = g.GameDate,
OtherTeamName = g.Team1ID == team.ID ? teams.First(t => t.ID == g.Team2ID).Name : teams.First(t => t.ID == g.Team1ID).Name,
DidWin = DidWin(g.Team1ID == team.ID, g.Team1Score, g.Team2Score),
HighScore = Math.Max(g.Team1Score, g.Team2Score),
LowScore = Math.Min(g.Team1Score, g.Team2Score),
}).ToList(),
Teams = teams.Select(t => new TeamsResult()
{
ID = t.ID,
Name = t.Name
}).ToList(),
AvailablePlayers = players.Where(p => !team.Players.Exists(tp => tp.ID == p.ID)).Select(p => new PlayersResult()
{
ID = p.ID,
Name = p.Name,
}).ToList(),
TeamPlayerStats = playerStats.Select(s => ConvertObjects.ConvertType(s)).ToList(),
StatTypes = statTypes.Select(s => ConvertObjects.ConvertType(s)).ToList(),
};
return(teamResult);
}
public void TeamModelToViewModelTest()
{
var model = new TeamResult
{
EndTime = DateTime.Now,
NumberOfPoints = 1,
NumberOfStages = 2,
StageResults = new List <StageResult>(),
TeamName = "a",
TeamNumber = 3,
TotalValue = 4
};
var result = _Sut.Map <TeamResultViewModel>(model);
Assert.AreEqual(model.EndTime, result.EndTime);
Assert.AreEqual(model.NumberOfPoints, result.NumberOfPoints);
Assert.AreEqual(model.NumberOfStages, result.NumberOfStages);
Assert.IsNotNull(result.StageResults);
Assert.AreEqual(model.TeamName, result.TeamName);
Assert.AreEqual(model.TeamNumber, result.TeamNumber);
Assert.AreEqual(model.TotalValue, result.TotalValue);
}
public TeamResult AddTeamResult([FromBody] TeamResultJson data)
{
var result = GetResult(data.id);
var score = data.score;
if (data.penalty > 0)
{
var onePercent = (float)score / (float)100;
score = (int)(onePercent * (float)data.penalty);
}
var teamResult = new TeamResult(data.teamId, score, data.penalty);
if (result?.TeamResults == null)
{
result = new Result(data.id, FplDataProvider.Season);
result.TeamResults.Add(teamResult);
_mongoResultProvider.AddResult(result);
}
else
{
if (result.TeamResults.Count(x => x.TeamId == data.teamId) > 0)
{
result.TeamResults.FirstOrDefault(x => x.TeamId == data.teamId).Score = score;
result.TeamResults.FirstOrDefault(x => x.TeamId == data.teamId).Penalty = data.penalty;
}
else
{
result.TeamResults.Add(teamResult);
}
_mongoResultProvider.UpdateResult(data.id, result);
}
return(teamResult);
}
/// <summary>
/// Initialize <see cref="PlanningPokerController"/> object with Scrum Team data received from server.
/// </summary>
/// <param name="teamInfo">Scrum Team data received from server.</param>
/// <param name="username">Name of user joining the Scrum Team.</param>
/// <returns>Asynchronous operation.</returns>
public Task InitializeTeam(TeamResult teamInfo, string username)
{
var scrumTeam = teamInfo?.ScrumTeam;
if (scrumTeam == null)
{
throw new ArgumentNullException(nameof(teamInfo));
}
if (string.IsNullOrEmpty(username))
{
throw new ArgumentNullException(nameof(username));
}
if (scrumTeam.Members == null)
{
scrumTeam.Members = new List <TeamMember>();
}
if (scrumTeam.Observers == null)
{
scrumTeam.Observers = new List <TeamMember>();
}
ScrumTeam = scrumTeam;
User = FindTeamMember(username);
IsScrumMaster = User != null && User == ScrumTeam.ScrumMaster;
LastMessageId = -1;
SessionId = teamInfo.SessionId;
if (scrumTeam.EstimationResult != null)
{
_memberEstimations = GetMemberEstimationList(scrumTeam.EstimationResult);
}
else if (scrumTeam.EstimationParticipants != null)
{
_memberEstimations = scrumTeam.EstimationParticipants
.Where(p => p.Estimated).Select(p => new MemberEstimation(p.MemberName)).ToList();
}
else
{
_memberEstimations = null;
}
IsConnected = true;
_hasJoinedEstimation = scrumTeam.EstimationParticipants != null &&
scrumTeam.EstimationParticipants.Any(p => string.Equals(p.MemberName, User?.Name, StringComparison.OrdinalIgnoreCase));
_selectedEstimation = null;
if (teamInfo is ReconnectTeamResult reconnectTeamInfo)
{
InitializeTeam(reconnectTeamInfo);
}
var memberCredentials = new MemberCredentials
{
TeamName = TeamName,
MemberName = User.Name
};
return(_memberCredentialsStore.SetCredentialsAsync(memberCredentials));
}
public void AddResult(int raceNumber, TeamResult result)
{
if (!_results.ContainsKey(result.Team.Id))
{
_results.Add(result.Team.Id, new DetailedTeamChampionshipResult(result.Team, _season));
}
var championshipResult = _results[result.Team.Id];
championshipResult.AddResult(raceNumber, result);
}
public static async Task <State> GetRoomThenStartAfterCreateTeam(State s, System.Net.WebSockets.WebSocket webSocket, TeamResult team, string playerName, string[] carsNames)
{
/*
* 组队，队长状态下，队长点击了开始
*/
int roomIndex;
var roomInfo = await Room.getRoomNum(s.WebsocketID, playerName, carsNames);
roomIndex = roomInfo.RoomIndex;
s.Key = roomInfo.Key;
var sendMsg = Newtonsoft.Json.JsonConvert.SerializeObject(roomInfo);
var receivedMsg = await Team.SetToBegain(team, roomIndex);
// var receivedMsg = await Startup.sendInmationToUrlAndGetRes(Room.roomUrls[roomInfo.RoomIndex], sendMsg);
if (receivedMsg == "ok")
{
receivedMsg = await Startup.sendInmationToUrlAndGetRes(Room.roomUrls[roomInfo.RoomIndex], sendMsg);
if (receivedMsg == "ok")
{
await WriteSession(roomInfo, webSocket);
s.roomIndex = roomIndex;
s = await setOnLine(s, webSocket);
}
}
return(s);
}
/// <summary>
/// Set upload params
/// </summary>
/// <param name="loginResult">Auth user data for uploading</param>
/// <param name="project">Selected solution project data</param>
/// <returns></returns>
internal static Upload SetUploadSettings(LoginResult loginResult, Project project, bool cancelStatus)
{
cancelStatus = false;
PresetResult presetResult = null;
TeamResult teamResult = null;
BackgroundWorkerHelper bg = new BackgroundWorkerHelper(delegate(object obj)
{
_client = InitCxClient(loginResult);
if (_client == null)
{
return;
}
presetResult = GetPresets(loginResult, presetResult);
CxWSResponseGroupList teamXmlList = _client.ServiceClient.GetAssociatedGroupsList(loginResult.SessionId);
teamResult = new TeamResult();
teamResult.IsSuccesfull = teamXmlList.IsSuccesfull;
teamResult.Teams = new Dictionary <string, string>();
if (teamXmlList.GroupList != null && teamXmlList.GroupList.Length > 0)
{
for (int i = 0; i < teamXmlList.GroupList.Length; i++)
{
teamResult.Teams.Add(teamXmlList.GroupList[i].ID, teamXmlList.GroupList[i].GroupName);
}
}
if (_client != null)
{
_client.Close();
}
}, loginResult.AuthenticationData.ReconnectInterval * 1000, loginResult.AuthenticationData.ReconnectCount);
//Show wait dialog and perform server request in different thread to safe UI responsibility
if (!bg.DoWork(PRESETS_LOADING_TEXT))
{
cancelStatus = true;
return(null);
}
if (!presetResult.IsSuccesfull)
{
return(null);
}
var uploadData = new Upload(new EntityId(loginResult), project.ProjectName,
string.Format("{0} Description", project.ProjectName), presetResult.Presets, 0,
teamResult.Teams, Guid.Empty.ToString(), true);
if (_dispatcher == null)
{
_dispatcher = ServiceLocators.ServiceLocator.GetDispatcher();
}
if (_dispatcher != null)
{
_dispatcher.Dispatch(uploadData);
}
return(uploadData);
}
private static JoinTeamController CreateController(
IPlanningPokerInitializer planningPokerInitializer = null,
IPlanningPokerClient planningPokerService = null,
IMessageBoxService messageBoxService = null,
IBusyIndicatorService busyIndicatorService = null,
INavigationManager navigationManager = null,
IMemberCredentialsStore memberCredentialsStore = null,
bool memberExistsError = false,
TeamResult teamResult = null,
ReconnectTeamResult reconnectTeamResult = null,
string errorMessage = null,
MemberCredentials memberCredentials = null)
{
if (planningPokerInitializer == null)
{
var planningPokerInitializerMock = new Mock <IPlanningPokerInitializer>();
planningPokerInitializer = planningPokerInitializerMock.Object;
}
if (planningPokerService == null)
{
var planningPokerServiceMock = new Mock <IPlanningPokerClient>();
var joinSetup = planningPokerServiceMock.Setup(o => o.JoinTeam(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <CancellationToken>()));
var reconnectSetup = planningPokerServiceMock.Setup(o => o.ReconnectTeam(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>()));
if (memberExistsError)
{
joinSetup.ThrowsAsync(new PlanningPokerException(ReconnectErrorMessage));
if (errorMessage == null)
{
reconnectSetup.ReturnsAsync(reconnectTeamResult);
}
else
{
reconnectSetup.ThrowsAsync(new PlanningPokerException(errorMessage));
}
}
else
{
if (errorMessage == null)
{
joinSetup.ReturnsAsync(teamResult);
}
else
{
joinSetup.ThrowsAsync(new PlanningPokerException(errorMessage));
}
}
planningPokerService = planningPokerServiceMock.Object;
}
if (messageBoxService == null)
{
var messageBoxServiceMock = new Mock <IMessageBoxService>();
if (memberExistsError)
{
SetupReconnectMessageBox(messageBoxServiceMock, true);
}
messageBoxService = messageBoxServiceMock.Object;
}
if (busyIndicatorService == null)
{
var busyIndicatorServiceMock = new Mock <IBusyIndicatorService>();
busyIndicatorService = busyIndicatorServiceMock.Object;
}
if (navigationManager == null)
{
var navigationManagerMock = new Mock <INavigationManager>();
navigationManager = navigationManagerMock.Object;
}
if (memberCredentialsStore == null)
{
var memberCredentialsStoreMock = new Mock <IMemberCredentialsStore>();
memberCredentialsStoreMock.Setup(o => o.GetCredentialsAsync()).ReturnsAsync(memberCredentials);
memberCredentialsStore = memberCredentialsStoreMock.Object;
}
return(new JoinTeamController(planningPokerService, planningPokerInitializer, messageBoxService, busyIndicatorService, navigationManager, memberCredentialsStore));
}
/// <summary>
/// Creates an HTML file on the user's desktop (overwriting any existing file).
/// This will simply list each work item if the items are flat, or it will
/// list all the children of the items along with the title of the parent if
/// the items are hierarchical.
/// </summary>
public static void ExportItems(string queryName, TeamResult result)
{
var path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
path = Path.Combine(path, $"{queryName}.html");
Console.Write($"Exporting to {path}");
using (var file = new StreamWriter(path)) {
file.WriteLine(@"<html>
<head>
<style>
body {
font-family: ""-apple-system"", BlinkMacSystemFont, ""Segoe UI"", Roboto, ""Helvetica Neue"", Helvetica, Ubuntu, Arial, sans-serif, ""Apple Color Emoji"", ""Segoe UI Emoji"", ""Segoe UI Symbol"";
}
.idnumber {
font-weight: 700;
font-size: 12px;
color: #000000;
text-decoration: underline;
}
.badge {
display: inline-block;
border-radius: 3px;
padding-bottom: 2px;
padding-top: 2px;
padding-left: 5px;
padding-right: 5px;
font-size: 8px;
font-weight: 600
}
.tag {
background: #78909C;
color: #ffffff;
}
.state {
background: #673AB7;
color: #ffffff;
}
.iteration {
background: #2196F3;
color: #ffffff;
}
.title{
line-height: 25px;
font-size: 14px;
}
.parentTitle{
line-height: 45px;
font-size: 18px;
}
</style></head>");
if (result.QueryType == QueryType.Tree)
{
var previousParentTitle = string.Empty;
// these are hierarchical, so list each child and include the
// title of its parent
foreach (var parent in result.Items)
{
foreach (var child in parent.Items)
{
Console.Write(".");
if (previousParentTitle != parent.Title)
{
EmitParentItem(file, parent);
previousParentTitle = parent.Title;
}
EmitItem(file, child);
}
}
}
else
{
// these are flat, so just list each item
foreach (var item in result.Items)
{
Console.Write(".");
EmitItem(file, item);
}
}
file.WriteLine("</body></html>");
}
Console.WriteLine("done");
}
public static DivisionResult JudgeSync(GameList games, Division division, List <int> teamIds, List <int> winnerIds, List <TeamResult> teamResults)
{
DateTime start = DateTime.Now;
//List<TeamResult> teamResults = TeamResult.FilterByTeams(command.TeamResults, mTeamIds);
//Have a list of games and a list of winners, determine who won the division
//Find the teams with the most wins
List <int> divisionFinalistIds = TeamResult.GetWinningTeamIds(teamResults, RecordType.Conference, teamIds);
//divisionFinalistIds = mGames.GetWinnersFromTeams(mTeamIds, true, command.WinnerIds);
int finalWinner = -1;
//switch (divisionFinalistIds.Count)
//{
// case 1:
// finalWinner = divisionFinalistIds[0];
// break;
// case 2:
// {
// //See who won the head-to-head matchup
// int gameIndex = games.FindMatchupIndex(teamIds[0], teamIds[1]);
// if (winnerIds != null && gameIndex < winnerIds.Count)
// {
// finalWinner = winnerIds[gameIndex];
// }
// else
// {
// Game game = games[gameIndex];
// if (game.GameAlreadyPlayed)
// {
// finalWinner = game.WinnerId;
// }
// }
// break;
// }
// default:
// {
ITiebreaker tiebreaker = GetTiebreaker(division.ConferenceName);
finalWinner = tiebreaker.BreakTie(games, winnerIds, teamResults, divisionFinalistIds, division);
// break;
// }
//}
//if(finalWinner == 1)
//{
// TeamResult miamiResult = command.TeamResults.Where(result => result.TeamId == 1).ElementAt(0);
// if (miamiResult.ConferenceRecord.Wins != 5)
// {
// Console.WriteLine("Miami wins");
// foreach (TeamResult result in TeamResult.FilterByTeams(command.TeamResults, mTeamIds))
// {
// Console.WriteLine($" {result.TeamName}: {result.OverallRecord.Wins}-{result.OverallRecord.Losses} ({result.ConferenceRecord.Wins}-{result.ConferenceRecord.Losses})");
// }
// }
//}
return(new DivisionResult
{
WinnerId = finalWinner,
DivisionFinalistIds = divisionFinalistIds,
Milliseconds = (DateTime.Now - start).TotalMilliseconds
});
}
private void AddTeamOutcome(string team, Outcome outcome)
{
TeamResult teamResult;
if (this.teams.TryGetValue(team, out teamResult)) {
teamResult.AddOutcome(outcome);
} else {
teamResult = new TeamResult();
teamResult.AddOutcome(outcome);
this.teams.Add(team, teamResult);
}
}
public DetailedTeamChampionshipResult(ICompetitor competitor, Season season)
{
Competitor = competitor;
Races = season.Races.Count();
Results = new TeamResult[Races];
for (var i = 0; i < Races; i++)
{
Results[i] = new NullTeamResult(competitor, season);
}
}
public void AddResult(int raceNumber, TeamResult result)
{
if (result.Team.Id != Competitor.Id) return;
if (raceNumber > Results.Length) return;
Results[raceNumber - 1] = result;
}
