void Start()
{
player = GetComponent <MainPlayer> ();
input = GetComponent <TeamAssignment> ();
key = GetComponent <KeyframeScript> ();
record = GetComponent <Recording> ();
}
public async Task UpdateTeamPlayers(string[] selectedPlayers, Team team)
{
if (selectedPlayers == null)
{
team.PlayerAssignments = new List <TeamAssignment>();
return;
}
var selectedPlayersHS = new HashSet <string>(selectedPlayers);
var teamPlayers = new HashSet <int>(team.PlayerAssignments.Select(t => t.Team.Id));
foreach (var player in await GetPlayers())
{
if (selectedPlayersHS.Contains(team.Id.ToString()))
{
if (!teamPlayers.Contains(team.Id))
{
player.TeamAssignments.Add(new TeamAssignment {
PlayerId = player.Id, TeamId = team.Id
});
}
}
else
{
if (teamPlayers.Contains(team.Id))
{
TeamAssignment playerToRemove = player.TeamAssignments.FirstOrDefault(t => t.TeamId == team.Id);
await RemoveTeamAssignment(playerToRemove);
}
}
}
}
private bool ValidateLoopAssignment(int[] loop, Fork fork, int leg, TeamAssignment teamAssignment)
{
// Restriction 1: the first loop must be different for first N legs (N is number of loops)
if (leg < fork.numBranches)
{
for (int otherLeg = 0; otherLeg < leg; ++otherLeg)
{
int[] otherBranches = teamAssignment.legAssignForFork[fork].branchForLeg[otherLeg];
if (otherBranches.Length > 0 && otherBranches[0] == loop[0])
{
return(false);
}
}
}
// Restriction 2: the entire loop must be as different as possible.
int maxDups = leg / (int)Util.Factorial(fork.numBranches);
int dups = teamAssignment.legAssignForFork[fork].branchForLeg.Count(branch => Util.EqualArrays(branch, loop));
if (dups > maxDups)
{
return(false);
}
return(true);
}
void Awake()
{
player = GetComponent <MainPlayer> ();
input = GetComponent <TeamAssignment> ();
key = GetComponent <KeyframeScript> ();
stats = GetComponent <PlayerStats> ();
play = GetComponent <Playback> ();
gameManager = GameObject.Find("[GameManager]").GetComponent <GameManager> ();
// recUI.enabled = false;
// playUI.enabled = false;
// Set up Line Renderer
lr = player.gameObject.GetComponentInChildren <LineRenderer> ();
lr.enabled = false;
lr.widthMultiplier = 0.2f;
lr.material = mat;
lr.receiveShadows = true;
lr.alignment = LineAlignment.View;
lr.textureMode = LineTextureMode.Tile;
}
public void AssignTeams(List <StudentAssignment> data)
{
// Step 0 - Business Rules:
// - The smallest team size is four students
// - The largest team size is seven students
// - Clients with more than seven students must be broken into separate teams, each with a team letter(starting with 'A').
// - Only assign students to clients that have been confirmed as participating.
// Step 1 - OLTP
using (var context = new CapstoneContext())
{
foreach (var item in data)
{
var assignment = new TeamAssignment();
assignment.ClientId = item.ClientId;
assignment.StudentId = item.StudentId;
assignment.TeamNumber = item.TeamLetter;
context.TeamAssignments.Add(assignment);
}
// And... Commit all the changes
context.SaveChanges(); // OLTP all done
}
}
private void AddForkToTeamAssignment(Fork fork, int leg, TeamAssignment teamAssignment)
{
if (fork == null)
{
return;
}
if (fork.loop)
{
int count = 0;
int[] selectedLoop;
do
{
selectedLoop = RandomLoop(fork.numBranches);
++count;
} while (count < 200 && !ValidateLoopAssignment(selectedLoop, fork, leg, teamAssignment));
teamAssignment.legAssignForFork[fork].branchForLeg.Add(selectedLoop);
// All subforks are reached.
foreach (Fork subFork in fork.subForks)
{
AddForkToTeamAssignment(subFork, leg, teamAssignment);
}
}
else
{
int selectedBranch;
if (fork.fixedLegs != null && fork.fixedLegs[leg] >= 0)
{
// This is a fixed leg.
selectedBranch = fork.fixedLegs[leg];
}
else
{
// Get the branches remaining to be used for this team.
List <int> possibleBranches = GetPossibleBranches(fork);
for (int i = 0; i < leg; ++i)
{
if ((fork.fixedLegs == null || fork.fixedLegs[i] < 0) && teamAssignment.legAssignForFork[fork].branchForLeg[i].Length > 0)
{
possibleBranches.Remove(teamAssignment.legAssignForFork[fork].branchForLeg[i][0]);
}
}
// Pick a random one.
selectedBranch = possibleBranches[random.Next(possibleBranches.Count)];
}
// Store it.
teamAssignment.legAssignForFork[fork].branchForLeg.Add(new int[1] {
selectedBranch
});
// Only visit the selected subfork.
AddForkToTeamAssignment(fork.subForks[selectedBranch], leg, teamAssignment);
}
AddForkToTeamAssignment(fork.next, leg, teamAssignment);
}
public async Task UpdatePlayerTeams(string[] selectedTeams, Player player)
{
if (selectedTeams == null)
{
player.TeamAssignments = new List <TeamAssignment>();
return;
}
var selectedTeamsHS = new HashSet <string>(selectedTeams);
var playerTeams = new HashSet <int>(player.TeamAssignments.Select(t => t.Team.Id));
foreach (var team in await GetTeams())
{
if (selectedTeamsHS.Contains(team.Id.ToString()))
{
if (!playerTeams.Contains(team.Id))
{
player.TeamAssignments.Add(new TeamAssignment {
PlayerId = player.Id, TeamId = team.Id
});
}
}
else
{
if (playerTeams.Contains(team.Id))
{
TeamAssignment teamToRemoveDTO = player.TeamAssignments.FirstOrDefault(t => t.TeamId == team.Id);
await RemoveTeamAssignment(teamToRemoveDTO);
}
}
}
}
public async Task <IActionResult> OnPostAsync(string[] selectedTeams)
{
var newCoach = new Coach();
if (selectedTeams != null)
{
newCoach.TeamAssignments = new List <TeamAssignment>();
foreach (var team in selectedTeams)
{
var teamToAdd = new TeamAssignment
{
TeamID = int.Parse(team)
};
newCoach.TeamAssignments.Add(teamToAdd);
}
}
if (await TryUpdateModelAsync <Coach>(
newCoach,
"Coach",
i => i.FirstMidName, i => i.LastName,
i => i.HireDate, i => i.OfficeAssignment))
{
_context.Coaches.Add(newCoach);
await _context.SaveChangesAsync();
return(RedirectToPage("./Index"));
}
PopulateAssignedTeamData(_context, newCoach);
return(Page());
}
void Start()
{
rb = GetComponent <Rigidbody> ();
input = GetComponent <TeamAssignment> ();
gameManager = GameObject.Find("[GameManager]").GetComponent <GameManager> ();
// rec = GetComponent<Recording> ();
}
public void TeamAssignmentThrowsError()
{
var client = new TargetProcessClient
{
ApiSiteInfo = new ApiSiteInfo(TargetProcessRoutes.Route.TeamAssignments)
};
var teamAssignment = new TeamAssignment
{
};
}
public bool LegEquals(int leg, TeamAssignment other, int otherLeg)
{
foreach (Fork fork in outer.allForks)
{
if (!LegEqualForFork(fork, leg, other, otherLeg))
{
return(false);
}
}
return(true);
}
private TeamAssignment GeneratePotentialTeam()
{
TeamAssignment teamAssignment = new TeamAssignment(this);
teamAssignment.totalScore = 0;
for (int leg = 0; leg < numberLegs; ++leg)
{
teamAssignment.totalScore += AddLegToTeamAssignment(leg, teamAssignment);
}
return(teamAssignment);
}
// Use this for initialization
void Start()
{
gameManager = GameObject.Find("[GameManager]").GetComponent <GameManager> ();
input = GetComponent <TeamAssignment> ();
record = GetComponent <Recording> ();
key = GetComponent <KeyframeScript> ();
play = GetComponent <Playback> ();
//Starts each player in the default position
startIndexX = xCord;
startIndexZ = zCord;
ResetPlayerPos();
}
public Team CreateTeam(Team team, string[] selectedPlayers)
{
if (selectedPlayers != null)
{
team.PlayerAssignments.Clear();
foreach (var player in selectedPlayers)
{
var playerToAdd = new TeamAssignment {
PlayerId = int.Parse(player), TeamId = team.Id
};
team.PlayerAssignments.Add(playerToAdd);
}
}
return(team);
}
public Player CreatePlayer(Player player, string[] selectedTeams)
{
if (selectedTeams != null)
{
player.TeamAssignments.Clear();
foreach (var team in selectedTeams)
{
var teamToAdd = new TeamAssignment {
PlayerId = player.Id, TeamId = int.Parse(team)
};
player.TeamAssignments.Add(teamToAdd);
}
}
return(player);
}
// Add a leg to the given assignment with a low score (for that leg), and return the score assigned for that leg.
private int AddLegToTeamAssignment(int leg, TeamAssignment teamAssignment)
{
int minScore = int.MaxValue;
for (int count = 0; ; ++count)
{
AddForkToTeamAssignment(firstForkInCourse, leg, teamAssignment);
// Add empty branch for forks that are not hit in this leg.
foreach (Fork fork in allForks)
{
if (teamAssignment.legAssignForFork[fork].branchForLeg.Count == leg)
{
teamAssignment.legAssignForFork[fork].branchForLeg.Add(new int[0]);
}
}
int score = ScoreLegAssignment(leg, teamAssignment);
if (score == 0)
{
return(score); // perfect enough to return.
}
if (score <= minScore && count > 20)
{
return(score); // good enough; as good as all previous and more than 20 considered.
}
if (score <= minScore * 4 / 3 && count > 50)
{
return(score);
}
if (score <= minScore * 2 && count > 75)
{
return(score);
}
if (count > 100)
{
return(score);
}
minScore = Math.Min(minScore, score);
foreach (Fork fork in allForks)
{
RemoveForkFromTeamAssignment(fork, leg, teamAssignment);
}
}
}
private TeamAssignment GenerateTeam()
{
// Return a potential team that doesn't duplicate previous teams, or failing that,
// with the minimum number of duplicates.
int minDupCount = int.MaxValue;
int minTotalScore = int.MaxValue;
TeamAssignment minTeam = null;
// Try 100 teams, first prioritizing number of complete duplicates, then
// prioritizing total score.
for (int i = 0; i < 100; ++i)
{
TeamAssignment team = GeneratePotentialTeam();
int countDups = results.Count(existingTeam => existingTeam.Equals(team));
if (countDups < minDupCount)
{
// duplicates takes priority always.
minDupCount = countDups;
minTotalScore = team.totalScore;
minTeam = team;
}
else if (countDups == minDupCount && team.totalScore <= minTotalScore)
{
// if # duplicates is the same, then prioritize by score.
if (team.totalScore == minTotalScore && i >= 10)
{
return(team);
}
minTotalScore = team.totalScore;
minTeam = team;
}
if (countDups == 0 && team.totalScore == 0)
{
return(team); // can't be better than 0 on both measures.
}
if (countDups == 0 && i > 25)
{
break;
}
}
Debug.WriteLine("Team {0} formed with {1} dups, totalScore of {2}", results.Count, minDupCount, minTeam.totalScore);
return(minTeam);
}
public void UpdateCoachTeams(SchoolContext context,
string[] selectedTeams, Coach coachToUpdate)
{
#region snippet_IfNull
if (selectedTeams == null)
{
coachToUpdate.TeamAssignments = new List <TeamAssignment>();
return;
}
#endregion
var selectedTeamsHS = new HashSet <string>(selectedTeams);
var coachTeams = new HashSet <int>
(coachToUpdate.TeamAssignments.Select(c => c.Team.TeamID));
foreach (var team in context.Teams)
{
#region snippet_UpdateCourses
if (selectedTeamsHS.Contains(team.TeamID.ToString()))
{
if (!coachTeams.Contains(team.TeamID))
{
coachToUpdate.TeamAssignments.Add(
new TeamAssignment
{
CoachID = coachToUpdate.ID,
TeamID = team.TeamID
});
}
}
#endregion
#region snippet_UpdateCoursesElse
else
{
if (coachTeams.Contains(team.TeamID))
{
TeamAssignment courseToRemove
= coachToUpdate
.TeamAssignments
.SingleOrDefault(i => i.TeamID == team.TeamID);
context.Remove(courseToRemove);
}
}
#endregion
}
}
public bool LegEqualForFork(Fork fork, int leg, TeamAssignment other, int otherLeg)
{
int[] thisForkLeg = legAssignForFork[fork].branchForLeg[leg];
int[] otherForkLeg = other.legAssignForFork[fork].branchForLeg[otherLeg];
if (thisForkLeg.Length != otherForkLeg.Length)
{
return(false);
}
for (int j = 0; j < thisForkLeg.Length; ++j)
{
if (thisForkLeg[j] != otherForkLeg[j])
{
return(false);
}
}
return(true);
}
void Start()
{
health = GetComponent <HealthScript> ();
fuel = GetComponent <FuelScript> ();
stats = GetComponent <PlayerStats> ();
rb = GetComponent <Rigidbody> ();
input = GetComponent <TeamAssignment> ();
if (input.myTeam == TeamAssignment.Team.TEAM_A)
{
playerNum = 1;
}
else
{
playerNum = 2;
}
}
override public bool Equals(object obj)
{
TeamAssignment other = obj as TeamAssignment;
if (other == null)
{
return(false);
}
foreach (Fork fork in outer.allForks)
{
if (!legAssignForFork[fork].Equals(other.legAssignForFork[fork]))
{
return(false);
}
}
return(true);
}
// Use this for initialization
void Start()
{
stats = GetComponent <PlayerStats> ();
health = GetComponent <HealthScript> ();
fuel = GetComponent <FuelScript> ();
currentSpeed = defaultSpeed;
input = GetComponent <TeamAssignment> ();
// rb = GetComponent<Rigidbody> ();
ray = new Ray(transform.position, transform.forward);
if (input.myTeam == TeamAssignment.Team.TEAM_A)
{
playerNum = 1;
}
else
{
playerNum = 2;
}
}
protected override async Task Handle(Request request, CancellationToken cancellationToken)
{
var team = await
session.Get <Team>(request.TeamId.Value, cancellationToken : cancellationToken);
if (team == null)
{
throw new ArgumentNullException(nameof(team));
}
var member = await
session.Get <Member>(request.MemberId.Value, cancellationToken : cancellationToken);
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
var teamMember = new TeamAssignment(request.Id.Value, request.TeamId.Value, request.MemberId.Value);
await session.Add(teamMember);
await session.Commit();
}
// Use this for initialization
void Start()
{
health = GetComponent <HealthScript> ();
fuel = GetComponent <FuelScript> ();
rb = GetComponent <Rigidbody> ();
input = GetComponent <TeamAssignment> ();
stats = GetComponent <PlayerStats> ();
bullet = null;
if (input.myTeam == TeamAssignment.Team.TEAM_A)
{
playerNum = 1;
}
else
{
playerNum = 2;
}
mainCollider = GetComponent <BoxCollider> ();
zone1.gameObject.SetActive(false);
zone2.gameObject.SetActive(false);
}
private void AddLegToTeamAssignment(int leg, TeamAssignment teamAssignment)
{
int minScore = int.MaxValue;
for (int count = 0; ; ++count) {
AddForkToTeamAssignment(firstForkInCourse, leg, teamAssignment);
// Add empty branch for forks that are not hit in this leg.
foreach (Fork fork in allForks) {
if (teamAssignment.legAssignForFork[fork].branchForLeg.Count == leg)
teamAssignment.legAssignForFork[fork].branchForLeg.Add(new int[0]);
}
int score = ScoreLegAssignment(leg, teamAssignment);
if (score == 0)
return; // perfect enough to return.
if (score <= minScore && count > 50)
return; // good enough; as good as all previous and more than 50 considered.
minScore = Math.Min(minScore, score);
foreach (Fork fork in allForks) {
RemoveForkFromTeamAssignment(fork, leg, teamAssignment);
}
}
}
public static void Initialize(IServiceProvider serviceProvider)
{
using var context = new DatabaseContext(
serviceProvider.GetRequiredService <
DbContextOptions <DatabaseContext> >());
// Look for any movies or teams.
if (context.Players.Any())
{
Console.WriteLine("Not Empty database.");
return; // DB has been seeded
}
var players = new Player[]
{
new Player
{
Name = "Cristiano Ronaldo",
Description = "Fotball player.",
TeamAssignments = new List <TeamAssignment>()
},
new Player
{
Name = "Michael Phelps",
Description = "Swimmer with longer wingspan than his height.",
TeamAssignments = new List <TeamAssignment>()
},
new Player
{
Name = "Michael Jordan",
Description = "Basketball player.",
TeamAssignments = new List <TeamAssignment>()
},
new Player
{
Name = "Conor McGregor",
Description = "An Irish retired professional mixed martial artist and boxer.",
TeamAssignments = new List <TeamAssignment>()
}
};
context.Players.AddRange(players);
context.SaveChanges();
var teams = new Team[]
{
new Team
{
Name = "American Patriots",
Description = "Perfect for Americans who love their country."
},
new Team
{
Name = "Challengers",
Description = "You team always knows how to bring a challenge to the game."
},
new Team
{
Name = "Money Makers",
Description = "And damn good at it!"
},
new Team
{
Name = "The Producers",
Description = "A team that makes visions a reality."
}
};
context.Teams.AddRange(teams);
context.SaveChanges();
var teamAssignment = new TeamAssignment[]
{
new TeamAssignment
{
PlayerId = players.Single(p => p.Name == players[0].Name).Id,
TeamId = teams.Single(t => t.Name == teams[0].Name).Id
},
new TeamAssignment
{
PlayerId = players.Single(s => s.Name == players[0].Name).Id,
TeamId = teams.Single(t => t.Name == teams[1].Name).Id
},
new TeamAssignment
{
PlayerId = players.Single(s => s.Name == players[0].Name).Id,
TeamId = teams.Single(t => t.Name == teams[3].Name).Id
},
new TeamAssignment
{
PlayerId = players.Single(s => s.Name == players[1].Name).Id,
TeamId = teams.Single(t => t.Name == teams[0].Name).Id
},
new TeamAssignment
{
PlayerId = players.Single(s => s.Name == players[1].Name).Id,
TeamId = teams.Single(t => t.Name == teams[3].Name).Id
},
new TeamAssignment
{
PlayerId = players.Single(s => s.Name == players[2].Name).Id,
TeamId = teams.Single(t => t.Name == teams[3].Name).Id
},
new TeamAssignment
{
PlayerId = players.Single(s => s.Name == players[2].Name).Id,
TeamId = teams.Single(t => t.Name == teams[1].Name).Id
},
new TeamAssignment
{
PlayerId = players.Single(s => s.Name == players[3].Name).Id,
TeamId = teams.Single(t => t.Name == teams[1].Name).Id
},
};
context.TeamAssignments.AddRange(teamAssignment);
context.SaveChanges();
}
// Check to see how much the given leg assignment duplicates previous legs on this team,
// or previous team assignments for this leg. Return score (0 = perfect, higher = worse)
// indicating how good a match.
private int ScoreLegAssignment(int leg, TeamAssignment teamAssignment)
{
int score = 0;
// Check 1: check agains previous teams on same leg, add penalty if
// too many on same branch. Boost penalty for first leg and first fork.
bool firstFork = true;
foreach (Fork fork in allForks)
{
if (fork.fixedLegs != null && fork.fixedLegs[leg] >= 0)
{
continue; // This is a fixed branch; nothing to score.
}
int allowedSimilarBranches = (int)Math.Floor(1.17 * ((double)results.Count / fork.numNonFixedBranches));
int similarBranches = 0;
for (int i = 0; i < results.Count; ++i)
{
if (results[i].LegEqualForFork(fork, leg, teamAssignment, leg))
{
++similarBranches;
}
}
int penalty = Math.Max(0, (similarBranches - allowedSimilarBranches));
if (firstFork)
{
penalty *= 3;
}
if (leg == 0)
{
penalty *= 3;
}
score += penalty;
firstFork = false;
}
// Check 2: check again previous teams on same leg.
int allowedDuplicates = (results.Count / minUniquePathsByLeg[leg]);
if (allowedDuplicates >= 1)
{
allowedDuplicates += (int)Math.Ceiling((double)allowedDuplicates / 3); // allow some slop after all options used once.
}
int duplicates = 0;
for (int i = 0; i < results.Count; ++i)
{
if (results[i].LegEquals(leg, teamAssignment, leg))
{
++duplicates;
}
}
score += 10 * Math.Max(0, (duplicates - allowedDuplicates));
if (numberLegs <= minUniquePathsByLeg[leg])
{
// Check 3: check against previous legs on same team, if they should be unique
for (int otherLeg = 0; otherLeg < leg; ++otherLeg)
{
if (teamAssignment.LegEquals(leg, teamAssignment, otherLeg))
{
score += 100;
}
}
}
return(score);
}
private bool ValidateLoopAssignment(int[] loop, Fork fork, int leg, TeamAssignment teamAssignment)
{
// Restriction 1: the first loop must be different for first N legs (N is number of loops)
if (leg < fork.numBranches) {
for (int otherLeg = 0; otherLeg < leg; ++otherLeg) {
int[] otherBranches = teamAssignment.legAssignForFork[fork].branchForLeg[otherLeg];
if (otherBranches.Length > 0 && otherBranches[0] == loop[0])
return false;
}
}
// Restriction 2: the entire loop must be as different as possible.
int maxDups = leg / (int)Util.Factorial(fork.numBranches);
int dups = teamAssignment.legAssignForFork[fork].branchForLeg.Count(branch => Util.EqualArrays(branch, loop));
if (dups > maxDups)
return false;
return true;
}
public bool LegEquals(int leg, TeamAssignment other, int otherLeg)
{
foreach (Fork fork in outer.allForks) {
int[] thisForkLeg = legAssignForFork[fork].branchForLeg[leg];
int[] otherForkLeg = other.legAssignForFork[fork].branchForLeg[otherLeg];
if (thisForkLeg.Length != otherForkLeg.Length)
return false;
for (int j = 0; j < thisForkLeg.Length; ++j) {
if (thisForkLeg[j] != otherForkLeg[j])
return false;
}
}
return true;
}
private void RemoveForkFromTeamAssignment(Fork fork, int leg, TeamAssignment teamAssignment)
{
teamAssignment.legAssignForFork[fork].branchForLeg.RemoveAt(teamAssignment.legAssignForFork[fork].branchForLeg.Count - 1);
}
// Check to see how much the given leg assignment duplicates previous legs on this team,
// or previous team assignments for this leg. Return score (0 = perfect, higher = worse)
// indicating how good a match.
private int ScoreLegAssignment(int leg, TeamAssignment teamAssignment)
{
int score = 0;
// Check 1: check again previous teams on same leg.
int allowedDuplicates = (results.Count / minUniquePaths);
if (allowedDuplicates >= 1) {
allowedDuplicates += (int)Math.Ceiling((double)allowedDuplicates / 3); // allow some slop after all options used once.
}
int duplicates = 0;
for (int i = 0; i < results.Count; ++i) {
if (results[i].LegEquals(leg, teamAssignment, leg))
++duplicates;
}
score += Math.Max(0, (duplicates - allowedDuplicates));
if (numberLegs <= minUniquePaths) {
// Check 2: check against previous legs on same team, if they should be unique
for (int otherLeg = 0; otherLeg < leg; ++otherLeg) {
if (teamAssignment.LegEquals(leg, teamAssignment, otherLeg))
score += 10;
}
}
return score;
}
public void CreateTeamAssignmentThrowsError()
{
var client = CommonMethods.GetClientByRoute(TargetProcessRoutes.Route.TeamAssignments);
var teamAssignment = new TeamAssignment();
}
/**
* Assign project to a team of Students
*
* - If rejectOthers is TRUE, set all other Application statuses to REJECTED
* - Change the application status of all studentIds to APPROVED
* - Create a Team object with TeamAssignment to the studentIds
* - For each student who is assigned to this project, close off
*/
public Team assignProject(long projectId, IList<long> applicationIds, bool rejectOthers)
{
Project project = this.getProjectById(projectId);
if (project == null)
throw new ProjectAssignmentException("Project Id " + projectId + " not found.");
if(project.PROJECT_STATUS != APPLICATION_STATUS.APPROVED)
throw new ProjectAssignmentException("Project Id " + projectId + " is not in the APPROVED status.");
if(applicationIds.Count <= 0 )
throw new ProjectAssignmentException("Please select at least 1 application.");
IList<ProjectApplication> allApplications = project.APPLICATIONS;
IList<ProjectApplication> successfulApplications = new List<ProjectApplication>();
IList<ProjectApplication> failedApplications = new List<ProjectApplication>();
if (session == null || !session.IsOpen)
{
session = hibernate.getSession();
}
//Update successful applications
session.BeginTransaction();
foreach (ProjectApplication application in allApplications)
{
if (applicationIds.Contains(application.APPLICATION_ID))
{
application.APPLICATION_STATUS = APPLICATION_STATUS.APPROVED;
successfulApplications.Add(application);
session.Update(application);
}
if (successfulApplications.Count % MAX_FLUSH_SIZE == 0)
session.Flush();
}
session.Flush();
//If rejectOthers flag is set as true, reject the rest of the applications
if (rejectOthers)
{
foreach (ProjectApplication application in allApplications)
{
if (!applicationIds.Contains(application.APPLICATION_ID))
{
application.APPLICATION_STATUS = APPLICATION_STATUS.REJECTED;
failedApplications.Add(application);
session.Update(application);
}
if (failedApplications.Count % MAX_FLUSH_SIZE == 0)
session.Flush();
}
session.Flush();
}
//Set Project status to ASSIGNED
project.PROJECT_STATUS = APPLICATION_STATUS.ASSIGNED;
//Create Team first
Team newTeam = new Team();
session.Save(newTeam);
//Create ProjectAssignment - relationship between Team and Project
ProjectAssignment pAssignment = new ProjectAssignment();
pAssignment.PROJECT = project;
pAssignment.TEAM = newTeam;
project.ASSIGNED_TEAMS.Add(pAssignment);
newTeam.ASSIGNED_TO_PROJECT.Add(pAssignment);
foreach (ProjectApplication application in successfulApplications)
{
//set team relationships
TeamAssignment tAssignment = new TeamAssignment();
Student student = application.APPLICANT;
tAssignment.STUDENT = student;
tAssignment.TEAM = newTeam;
//Close off all this student's applications
IList<ProjectApplication> existingApplications = student.PROJECTS_APPLIED;
foreach(ProjectApplication existingApplication in existingApplications)
{
if (existingApplication.APPLICATION_ID == application.APPLICATION_ID)
continue;
existingApplication.APPLICATION_STATUS = APPLICATION_STATUS.REJECTED;
session.Save(existingApplication);
}
//set opposite direction relationships
newTeam.TEAM_ASSIGNMENT.Add(tAssignment);
student.TEAM_ASSIGNMENT.Add(tAssignment);
//set assignment attributes
tAssignment.ROLE = TEAM_ASSIGNMENT_ROLE.MEMBER;
session.Save(tAssignment);
session.Save(student);
}
session.Save(pAssignment);
session.Save(project);
session.Save(newTeam);
//session.Flush();
session.Transaction.Commit();
//send emails to:
//1. Project Owner
//2. Project members
EmailModule emailModule = new EmailModule();
string ownerSubject = "Congratulations! Your project has been assigned!";
string ownerMessage = "<h2>Your project " + project.PROJECT_TITLE + " has been assigned to the following students:<h2> <br />";
foreach(TeamAssignment ta in newTeam.TEAM_ASSIGNMENT)
{
Student member = ta.STUDENT;
ownerMessage += "- " + member.FIRSTNAME + " " + member.LASTNAME + " (Student ID: " + member.USER_ID + ", Email: " + member.EMAIL + ") <br />";
}
emailModule.sendEmail(ownerSubject, ownerMessage, project.PROJECT_OWNER.EMAIL);
string studentSubject = "Congratulations! You have been assigned to a project!";
string studentMessage = "<h2>You have been assigned to the following project:</h2> <br />";
studentMessage += "'" + project.PROJECT_TITLE + "' (Project ID: " + project.PROJECT_ID + ") <br />";
studentMessage += "By company: " + project.PROJECT_OWNER.USERNAME + " (Company reg num: " + project.PROJECT_OWNER.COMPANY_REG_NUM + ") <br />";
studentMessage += "Contact person: " + project.CONTACT_NAME + " <br />";
studentMessage += "Contact email: " + project.CONTACT_EMAIL + " <br />";
studentMessage += "Contact phone: " + project.CONTACT_NUMBER + " <br />";
IList<string> addresses = new List<string>();
foreach (TeamAssignment ta in newTeam.TEAM_ASSIGNMENT)
{
Student member = ta.STUDENT;
addresses.Add(member.EMAIL);
}
emailModule.sendEmailToMany(studentSubject, studentMessage,addresses);
return newTeam;
}
private void AddForkToTeamAssignment(Fork fork, int leg, TeamAssignment teamAssignment)
{
if (fork == null)
return;
if (fork.loop) {
int count = 0;
int[] selectedLoop;
do {
selectedLoop = RandomLoop(fork.numBranches);
++count;
} while (count < 200 && !ValidateLoopAssignment(selectedLoop, fork, leg, teamAssignment));
teamAssignment.legAssignForFork[fork].branchForLeg.Add(selectedLoop);
// All subforks are reached.
foreach (Fork subFork in fork.subForks)
AddForkToTeamAssignment(subFork, leg, teamAssignment);
}
else {
// Get the branches remaining to be used for this team.
List<int> possibleBranches = GetPossibleBranches(fork);
for (int i = 0; i < leg; ++i) {
if (teamAssignment.legAssignForFork[fork].branchForLeg[i].Length > 0)
possibleBranches.Remove(teamAssignment.legAssignForFork[fork].branchForLeg[i][0]);
}
// Pick a random one.
int selectedBranch = possibleBranches[random.Next(possibleBranches.Count)];
// Store it.
teamAssignment.legAssignForFork[fork].branchForLeg.Add(new int[1] { selectedBranch });
// Only visit the selected subfork.
AddForkToTeamAssignment(fork.subForks[selectedBranch], leg, teamAssignment);
}
AddForkToTeamAssignment(fork.next, leg, teamAssignment);
}
private async Task MakeTeamsCommand(int numberOfTeams)
{
try
{
// Define variables
int teamNumber;
int randomUserPosition;
int userCount;
List <int> usedPositions;
SocketVoiceChannel curVoiceChannel;
string messageOutput;
SocketGuildUser[] users;
SocketGuildUser messageAuthor;
List <TeamAssignment> teamAssignmentList;
TeamAssignment curUserTeamAssignment;
List <IChannel> teamChannels;
// Initialise variables
messageOutput = "";
teamAssignmentList = new List <TeamAssignment> {
};
usedPositions = new List <int> {
};
teamChannels = new List <IChannel> {
};
teamNumber = 1;
messageAuthor = this.Context.Message.Author as SocketGuildUser;
curVoiceChannel = messageAuthor.VoiceChannel;
// Check that the caller is in a voice channel
if (curVoiceChannel == null)
{
messageOutput += string.Format("{0}, you must be in a voice channel to use this command", messageAuthor.Username);
}
else
{
// make array of users in the current voice channel
users = curVoiceChannel.Users.ToArray();
userCount = users.Length;
if (numberOfTeams > userCount)
{
numberOfTeams = userCount;
}
// Assign team numbers to users
while (userCount > usedPositions.Count)
{
curUserTeamAssignment = new TeamAssignment();
// Choose a random user from who is left
do
{
randomUserPosition = CoOpGlobal.rng.Next(0, userCount);
}while (usedPositions.Contains(randomUserPosition));
curUserTeamAssignment.user = users[randomUserPosition];
curUserTeamAssignment.teamNumber = teamNumber;
teamAssignmentList.Add(curUserTeamAssignment);
// Mark this position as being used
usedPositions.Add(randomUserPosition);
teamNumber++;
if (teamNumber > numberOfTeams)
{
teamNumber = 1;
}
}
// Make sure the team chat channels exist
for (int i = 1; i <= numberOfTeams; i++)
{
string teamChannelName;
IReadOnlyCollection <IVoiceChannel> voiceChannels;
Boolean teamChannelExists = false;
IVoiceChannel teamVoiceChannel = null;
teamChannelName = string.Format("Team {0}", i);
voiceChannels = await this.Context.Guild.GetVoiceChannelsAsync();
for (int j = 0; j < voiceChannels.Count; j++)
{
SocketVoiceChannel voiceChannel;
voiceChannel = voiceChannels.ElementAt(j) as SocketVoiceChannel;
if (voiceChannel.Name == teamChannelName)
{
teamVoiceChannel = voiceChannel;
teamChannelExists = true;
}
}
if (teamChannelExists == false)
{
teamVoiceChannel = await this.Context.Guild.CreateVoiceChannelAsync(teamChannelName);
}
teamChannels.Add(teamVoiceChannel);
}
// Move teams to their voice channels
foreach (TeamAssignment assignment in teamAssignmentList)
{
IGuildUser teamUser;
int team;
IVoiceChannel teamChannel;
teamUser = assignment.user as IGuildUser;
team = assignment.teamNumber;
teamChannel = teamChannels.ElementAt(team - 1) as IVoiceChannel;
await(teamUser)?.ModifyAsync(x =>
{
x.ChannelId = teamChannel.Id;
});
}
messageOutput += string.Format("Made {0} teams", numberOfTeams);
}
await ReplyAsync(messageOutput);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task RemoveTeamAssignment(TeamAssignment teamAssignment)
{
_context.Remove(teamAssignment);
await this.SaveChanges();
}
private TeamAssignment GeneratePotentialTeam()
{
TeamAssignment teamAssignment = new TeamAssignment(this);
for (int leg = 0; leg < numberLegs; ++leg) {
AddLegToTeamAssignment(leg, teamAssignment);
}
return teamAssignment;
}
private void RemoveForkFromTeamAssignment(Fork fork, int leg, TeamAssignment teamAssignment)
{
teamAssignment.legAssignForFork[fork].branchForLeg.RemoveAt(teamAssignment.legAssignForFork[fork].branchForLeg.Count - 1);
}
