private static async Task <Models.Db.Team> CreateTeam(IDbConnection c, IDbTransaction t, IStorageProvider storage, GroupCoords coords, FootballData.Team team, int sequenceOrder)
{
var logoImgUrl = ImportImage(c, t, storage, team.CrestUrl);
var dbTeam = new Models.Db.Team
{
Name = team.Name,
KeyName = String.IsNullOrWhiteSpace(team.Code) ? team.Name.Substring(0, 3) : team.Code,
LogoImgUrl = logoImgUrl,
Status = (int)TeamStatus.Inscribed
};
dbTeam.Id = await c.InsertAsync(dbTeam, t);
await c.InsertAsync(new TournamentTeam
{
IdTeam = dbTeam.Id,
IdTournament = coords.IdTournament
}, t);
var teamGroup = new TeamGroup
{
IdTeam = dbTeam.Id,
IdGroup = coords.IdGroup,
IdStage = coords.IdStage,
IdTournament = coords.IdTournament,
SequenceOrder = sequenceOrder
};
await c.InsertAsync(teamGroup, t);
return(dbTeam);
}
private static TeamGroup Parse(string fullString)
{
TeamGroup tg = new TeamGroup();
int index = fullString.IndexOf("group = '");
if (index >= 0)
{
index += "group = '".Length;
int endIndex = fullString.IndexOf("'", index);
if (endIndex >= 0)
{
tg.Group = fullString.Substring(index, endIndex - index).Trim(' ', '\'');
endIndex += 1;
index = fullString.IndexOf(" and (team in (", endIndex);
if (index >= 0)
{
index += " and (team in (".Length;
endIndex = fullString.IndexOf(")", index);
if (endIndex >= 0)
{
string allTeamsString = fullString.Substring(index, endIndex - index);
tg.Teams = allTeamsString.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(t => t.Trim(' ', '\''))
.ToArray();
}
}
}
}
return(tg);
}
public static bool IsIncludedIn(this Team subjectTeam, TeamGroup teamGroup)
{
// Test multi-team TeamGroups.
switch (teamGroup)
{
case TeamGroup.None:
// TODO: See if it's necessary (we might not need to check for `TeamGroup.None` ever).
return(false);
case TeamGroup.All:
return(true);
case TeamGroup.FriendliesAndNeutrals:
return(subjectTeam.Equals(Team.Friendly) || subjectTeam.Equals(Team.Neutral));
case TeamGroup.FriendliesAndEnemies:
return(subjectTeam.Equals(Team.Friendly) || subjectTeam.Equals(Team.Enemy));
case TeamGroup.NeutralsAndEnemies:
return(subjectTeam.Equals(Team.Neutral) || subjectTeam.Equals(Team.Enemy));
case TeamGroup.Friendlies:
case TeamGroup.Neutrals:
return(((int)subjectTeam) + 1 == (int)teamGroup);
case TeamGroup.Enemies:
return(((int)subjectTeam) + 2 == (int)teamGroup);
default:
throw new Exception($"Given multi-team TeamGroup {teamGroup.ToString()} isn't implemented for extension method 'IsIncludedIn'.");
}
}
public static WTeamGroup ConvertTeamGroup(TeamGroup DbTeamGroup)
{
return(new WTeamGroup
{
Id = DbTeamGroup.Id,
Title = DbTeamGroup.Title,
Uid = DbTeamGroup.Uid
});
}
private void Start()
{
players = new List <GameObject>();
playerTeams = new List <List <GameObject> > {
new List <GameObject>(), new List <GameObject>()
};
clientTeam = TeamGroup.TeamNotAssigned;
}
public IList<TeamGroup> GetAllTeamGroups(string openId)
{
IDictionary<string, string> companyNameDict = DAOProperty.GetComanyNameDictionary(openId);
IList<TeamGroup> groupList = DAOProperty.GetAllTeams(openId);
IList<CarEntity> carList = DAOProperty.GetAllCars(openId);
// tid=0的情况的处理
IList<string> emptyTeamList = GetEmptyTeamList(carList);
foreach (string cid in emptyTeamList)
{
TeamGroup teamGroup = new TeamGroup()
{
cid = cid,
cname = companyNameDict[cid],
tid = "0",
tname = "无车队",
carList = new List<CarRealtimeInfo>()
};
groupList.Add(teamGroup);
}
IList<string> vidList = new List<string>();
foreach (CarEntity car in carList)
{
vidList.Add(car.vid);
}
IList<CarRealtimeData> carDataList = DAOProperty.GetAllCarRealtimeDatas(openId, vidList, "30");
// Generate a dictionary of CarRealtimeData
IDictionary<string, CarRealtimeData> carDataDict = new Dictionary<string, CarRealtimeData>();
foreach (CarRealtimeData item in carDataList)
{
carDataDict.Add(item.vid, item);
}
// 对车辆分组groupList按照公司ID来排序, cid
IList<TeamGroup> newGroupList = groupList.OrderBy((item) => item.cid).ToList();
foreach (TeamGroup team in newGroupList)
{
team.cname = companyNameDict[team.cid];
team.carList = (from CAR in carList
where (CAR.tid.Equals(team.tid) && CAR.cid.Equals(team.cid) )
select new CarRealtimeInfo()
{
vid = CAR.vid ?? string.Empty,
vLicense = CAR.vLicense ?? string.Empty,
position = (!string.IsNullOrEmpty(CAR.vid) && carDataDict.ContainsKey(CAR.vid)) ? carDataDict[CAR.vid].position : string.Empty,
speed = (!string.IsNullOrEmpty(CAR.vid) && carDataDict.ContainsKey(CAR.vid)) ? carDataDict[CAR.vid].speed : string.Empty,
gpsTime = (!string.IsNullOrEmpty(CAR.vid) && carDataDict.ContainsKey(CAR.vid)) ? carDataDict[CAR.vid].gpsTime : string.Empty
}).ToList<CarRealtimeInfo>();
}
return newGroupList;
}
public TeamEditPage(TeamMainPage _TeamMainPage, TeamGroup TGroup)
{
InitializeComponent();
LoadWindowParent(_TeamMainPage);
EventsInitialize();
this.TGroup = TGroup;
TextBox_TeamName.Text = TGroup.Title;
TextBox_TeamUid.Text = TGroup.Uid;
}
public TeamEditAccessPage(TeamMainPage _TeamMainPage, TeamGroup TGroup)
{
InitializeComponent();
LoadParentWindows(_TeamMainPage);
NetworkEvents();
EventsInitialize();
this.TGroup = TGroup;
DataGrid_Access.ItemsSource = AccessCollecton;
DataGrid_Access.IsEnabled = false;
Sender.SendToServer("Access.GetAll");
}
/// <summary>
/// Loads the team group.
/// </summary>
/// <returns>TeamGroup</returns>
/// <param name="leagueName">string</param>
/// <param name="year">int</param>
/// <param name="database">Db</param>
/// <param name="seriesLength">int</param>
public static TeamGroupTree LoadRoot(string leagueName, int year, Db database, int seriesLength = 3)
{
TeamGroupTree league = null;
Dictionary <string, TeamGroup> divisions = new Dictionary <string, TeamGroup>();
SQLStoredProcedure sp = StoredProcedureManager.Get("GetDivisionInfo");
sp.Parameters = new object[] { leagueName, year };
SQLQueryResult result = database.ExecuteQuery(sp.Text);
DataTable teamGroupInfo = result.DataTable;
string leagueID = teamGroupInfo.Rows[0]["lgID"].ToString();
foreach (DataRow row in teamGroupInfo.Rows)
{
string teamID = row["teamID"].ToString();
string teamName = row["name"].ToString();
string divID = row["divID"].ToString();
TeamGroup group = null;
Team team = null;
team = DatabaseTeamLoader.LoadTeam(teamName, year, database);
if (!divisions.ContainsKey(divID))
{
group = new TeamGroup(divID, divID);
divisions.Add(divID, group);
if (!group.Contains(team))
{
group.Add(team);
}
}
else
{
divisions[divID].Add(team);
}
Console.WriteLine($"Added {team} to division '{divID}'");
System.Threading.Thread.Sleep(150);
}
league = new TeamGroupTree(leagueID, leagueName, seriesLength);
foreach (TeamGroup division in divisions.Values)
{
league.Add(division);
Console.WriteLine($"Added division '{division.Name}' to league '{league.Name}'");
System.Threading.Thread.Sleep(150);
}
return(league);
}
public void Register(GameObject adding, TeamGroup team)
{
players.Add(adding);
playerTeams[(int)team].Add(adding);
adding.GetComponent <FaceoffDeath>().OnPlayerDeath += PlayerDied;
// Make friendlies and enemies correct color
if (team == clientTeam)
{
adding.GetComponentInChildren <MeshRenderer>().material.color = Color.blue;
}
else
{
adding.GetComponentInChildren <MeshRenderer>().material.color = Color.red;
}
}
private void Button_TeamAdd_Click(object sender, RoutedEventArgs e)
{
var TGroup = new TeamGroup();
TGroup.Uid = TextBox_TeamUid.Text;
TGroup.Title = TextBox_TeamName.Text;
if (!Sender.SendToServer("TeamGroup.Add", TGroup))
{
new AlertWindow("Ошибка", AlertWindow.AlertCode.SendToServer);
}
else
{
TextBox_TeamUid.IsEnabled = false;
TextBox_TeamName.IsEnabled = false;
}
}
public static Team?AsSingleTeam(this TeamGroup teamGroup)
{
switch (teamGroup)
{
case TeamGroup.Friendlies:
return(Team.Friendly);
case TeamGroup.Neutrals:
return(Team.Neutral);
case TeamGroup.Enemies:
return(Team.Enemy);
default:
return(null);
}
}
public void PlayerDied(GameObject deadPlayer, TeamGroup team)
{
players.Remove(deadPlayer);
playerTeams[(int)team].Remove(deadPlayer);
if (playerTeams[0].Count == 0 || playerTeams[1].Count == 0)
{
TeamGroup winners = playerTeams[0].Count > 0 ? TeamGroup.TeamOne : TeamGroup.TeamTwo;
NotificationType notifType =
deadPlayer.GetPhotonView().IsMine ? NotificationType.Bad : NotificationType.Good;
NotificationSystem.Instance.Notify(new Notification($"Team {(int)winners + 1} won!", notifType));
if (PhotonNetwork.IsMasterClient)
{
StartCoroutine(StopGame());
}
}
}
static void RandomFacts(ref StreamWriter write, ref List <SuperBowl> listOfSuperBowls)
{
write.WriteLine("Here are some superbowl fun facts\n\n");
var coachQuery = from superBowl in listOfSuperBowls
group superBowl by superBowl.WinningCoach into CoachGroup
orderby CoachGroup.Count() descending
select CoachGroup;
write.WriteLine("The winningist coach is " + coachQuery.First().Key + ". He has won " + coachQuery.First().Count());
var coachQuery2 = from superBowl in listOfSuperBowls
group superBowl by superBowl.LosingCoach into CoachGroup2
orderby CoachGroup2.Count() descending
select CoachGroup2;
write.WriteLine("The coach that has lost the most superbowls is " + coachQuery2.First().Key + ". He has lost " + coachQuery2.First().Count());
var WinningQuery = from superBowl in listOfSuperBowls
group superBowl by superBowl.WinningTeamName into TeamGroup
orderby TeamGroup.Count() descending
select TeamGroup;
write.WriteLine("The team that has won the most superbowls is " + WinningQuery.First().Key + ". they have won " + WinningQuery.First().Count());
var LosingQuery = from superBowl in listOfSuperBowls
group superBowl by superBowl.LosingTeamName into TeamGroup2
orderby TeamGroup2.Count() descending
select TeamGroup2;
write.WriteLine("The team that has won the most superbowls is " + LosingQuery.First().Key +
". they have lost " + LosingQuery.First().Count());
double averageValue = listOfSuperBowls.Average(x => x.Attendance);
write.WriteLine("Average attendance of all superbowls was " + averageValue.ToString("n0"));
var PointDifferenceQuery = from superBowl in listOfSuperBowls
orderby superBowl.PointDifference descending
select superBowl;
write.WriteLine($"The super bowl with the biggest point difference was Super Bowl {PointDifferenceQuery.First().SuperBowlRomanNumeral}" +
$" in {PointDifferenceQuery.First().Date.Year}. It had a point difference of {PointDifferenceQuery.First().PointDifference}.");
}
private void UpdateTeamGroup(MResponse ClientResponse, MNetworkClient NetworkClient)
{
if (!AccessController.IsPrivilege(NetworkClient, "teams.edit"))
{
return;
}
try
{
using (var db = new DatabaseContext())
{
var MTeamGroup = Package.Unpacking <TeamGroup>(ClientResponse.DataBytes);
var DbTeamGroupCache = new TeamGroup
{
Id = MTeamGroup.Id,
Uid = MTeamGroup.Uid,
Title = MTeamGroup.Title,
UserId = MTeamGroup.UserId
};
var DbTeamGroup = db.TeamGroups.FirstOrDefault(t => t.Id == MTeamGroup.Id);
DbTeamGroup.Title = MTeamGroup.Title;
DbTeamGroup.Uid = MTeamGroup.Uid;
db.SaveChanges();
Debug.Log($"Информация о команде обновлена:\n" +
$"Id - {DbTeamGroupCache.Id} > {DbTeamGroup.Id}\n" +
$"TeamUid - {DbTeamGroupCache.Uid} > {DbTeamGroup.Uid}\n" +
$"Title - {DbTeamGroupCache.Title} > {DbTeamGroup.Title}\n" +
$"UserId - {DbTeamGroupCache.UserId} > {DbTeamGroup.UserId}", ConsoleColor.Magenta);
Sender.Broadcast("TeamGroup.Update.Confirm", DbTeamGroup, ClientResponse.WindowUid);
}
}
catch (DbUpdateException ex)
{
Debug.LogError("Возникла ошибка при обновлении команды в базе данных! Код ошибки:\n" + ex);
Sender.Send(NetworkClient, "TeamGroup.Update.Error");
}
}
public void RoundRobin_Success()
{
// Arrange
var teams = new[]
{
new Team
{
Id = 1
},
new Team
{
Id = 2
},
new Team
{
Id = 3
},
new Team
{
Id = 4
}
};
var group = new Group
{
Id = 1,
TeamGroups = new List <TeamGroup>()
};
foreach (var team in teams)
{
var teamGroup = new TeamGroup
{
Group = group,
Team = team
};
group.TeamGroups.Add(teamGroup);
}
// Act
var matches = new RoundRobinMatchmake().Matching(group);
// Assert
Assert.That(matches, Has.Count.EqualTo(6));
}
private static Group ArrangeGroup()
{
var teams = new[]
{
new Team
{
Id = 1,
Tier = Tier.First
},
new Team
{
Id = 2,
Tier = Tier.Second
},
new Team
{
Id = 3,
Tier = Tier.Third
},
new Team
{
Id = 4,
Tier = Tier.Fourth
}
};
var group = new Group
{
Id = 1,
TeamGroups = new List <TeamGroup>()
};
foreach (var team in teams)
{
var teamGroup = new TeamGroup
{
Group = group,
Team = team
};
group.TeamGroups.Add(teamGroup);
}
return(group);
}
private static void DrawSetIntoGroups(List <Group> groups, List <Pot> firstPotsSet, int set)
{
foreach (var group in groups.Where(g => groups.IndexOf(g) % 2 == set))
{
foreach (var pot in firstPotsSet)
{
var teams = pot.TeamPots.Select(tp => tp.Team).ToArray();
var randomTeam = teams[_random.Next(0, teams.Length)];
var randomTeamPot = pot.TeamPots.Single(tp => tp.TeamId == randomTeam.Id);
pot.TeamPots.Remove(randomTeamPot);
var teamGroup = new TeamGroup
{
Group = group,
Team = randomTeam
};
group.TeamGroups.Add(teamGroup);
}
}
}
public static List <Team> AsTeamList(this TeamGroup teamGroup)
{
List <Team> teamList = new List <Team>();
bool isAll = teamGroup == TeamGroup.All,
isFrAndEn = teamGroup == TeamGroup.FriendliesAndEnemies,
isFrAndNe = teamGroup == TeamGroup.FriendliesAndNeutrals,
isNeAndEn = teamGroup == TeamGroup.NeutralsAndEnemies;
if (isAll || teamGroup == TeamGroup.Friendlies || isFrAndEn || isFrAndNe)
{
teamList.Add(Team.Friendly);
}
if (isAll || teamGroup == TeamGroup.Neutrals || isFrAndNe || isNeAndEn)
{
teamList.Add(Team.Neutral);
}
if (isAll || teamGroup == TeamGroup.Enemies || isFrAndEn || isNeAndEn)
{
teamList.Add(Team.Enemy);
}
return(teamList);
}
public void PlayerDied(int actor)
{
TeamGroup team = GetComponent <Team>().team;
// Notification
if (actor != -1)
{
NotificationType notifType = NotificationType.Good;
FaceoffPlayerManager pManager = FindObjectOfType <FaceoffPlayerManager>();
// If my client is the dead player
if (photonView.IsMine)
{
notifType = NotificationType.Bad;
}
// Or if the dead player has a teammate who is my client
else
{
IEnumerable <GameObject> teamMates = pManager.GetTeammates(gameObject, team);
foreach (var mate in teamMates)
{
if (mate.GetPhotonView().IsMine)
{
notifType = NotificationType.Bad;
break;
}
}
}
NotificationSystem.Instance.Notify(new Notification($"Player {actor} killed Player {photonView.ControllerActorNr}", notifType));
}
if (photonView.IsMine)
{
Instantiate(deathUI);
}
// Hit all death events
try
{
OnPlayerDeath?.Invoke(gameObject, team);
}
catch (Exception)
{
Debug.Log("Exception");
}
if (photonView.IsMine)
{
// GetComponent<PlayerMotor>().normalCam = deathCam;
GetComponent <PlayerMotor>().speed = 0;
GetComponent <PlayerMotor>().speedModifier = 0;
GetComponent <PlayerMotor>().sprintModifier = 0;
GetComponent <PlayerMotor>().jumpForce = 0;
UI.SetActive(false);
Cursor.lockState = CursorLockMode.None;
Cursor.visible = true;
}
if (photonView.IsMine)
{
PhotonNetwork.Destroy(this.gameObject);
}
}
public static TeamGroup Parseout(string fullstring)
{
TeamGroup tg = Parse(fullstring);
return(tg);
}
private void Clear()
{
TeamGroup?.Clear();
}
private async void Get()
{
var jData = await DataService.Get("Cluster");
if (jData == "ConnectionError")
{
StandardMessagesDisplay.NoConnectionToast();
}
else if (jData == "null")
{
StandardMessagesDisplay.NoDataDisplayMessage();
}
else if (jData == "Error")
{
StandardMessagesDisplay.Error();
}
else if (jData == "ErrorTracked")
{
StandardMessagesDisplay.ErrorTracked();
}
else
{
try
{
var data = JsonConvert.DeserializeObject <Dictionary <string, ClusterModel> >(jData);
if (data != null)
{
foreach (KeyValuePair <string, ClusterModel> item in data)
{
var nestedJData = await DataService.Get($"Team/{item.Value.Id}");
if (nestedJData == "ConnectionError")
{
StandardMessagesDisplay.NoConnectionToast();
}
else if (nestedJData == "null")
{
StandardMessagesDisplay.NoDataDisplayMessage();
}
else if (nestedJData == "Error")
{
StandardMessagesDisplay.Error();
}
else if (nestedJData == "ErrorTracked")
{
StandardMessagesDisplay.ErrorTracked();
}
else
{
var nestedData = JsonConvert.DeserializeObject <Dictionary <string, TeamModel> >(nestedJData);
List <TeamModel> lp = new List <TeamModel>();
if (nestedData != null)
{
foreach (KeyValuePair <string, TeamModel> item2 in nestedData)
{
lp.Add(
new TeamModel
{
Id = item2.Value.Id,
CHWName = item2.Value.CHWName,
FId = item2.Value.FId,
SocialMobilizerId = item2.Value.SocialMobilizerId,
TeamNo = item2.Value.TeamNo
});
}
}
TeamGroup?.Add(new TeamsGroupedByClusterModel(item.Value.ClusterName, lp));
}
}
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
StandardMessagesDisplay.InputToast(ex.Message);
}
}
}
void SetTeam(int newTeam)
{
team = (TeamGroup)newTeam;
FindObjectOfType <FaceoffPlayerManager>().Register(gameObject, GetComponent <Team>().team);
}
void Awake()
{
team = TeamGroup.TeamNotAssigned;
}
public static bool Includes(this TeamGroup teamGroup, Team subjectTeam) => subjectTeam.IsIncludedIn(teamGroup);
public IEnumerable <GameObject> GetTeammates(GameObject player, TeamGroup team)
{
return(playerTeams[(int)team].Where((p => p != player)));
}
