public TeamsController()
{
_teamRepository = new TeamRepository(AppUser);
_teamService = new TeamService(AppUser);
_teamRepository.OnChange += SyncManager.OnChange;
_teamService.OnChange += SyncManager.OnChange;
}
/// <summary>
/// Prevents a default instance of the <see cref="Database"/> class from being created.
/// Use <see cref="Database.Instance"/> to access the Singleton.
/// </summary>
/// <param name="filePath">The file path providing the database configuration file.</param>
private Database(string filePath)
{
database = PgDb.Create(filePath);
// Init services
playerService = PlayerService.GetInstance(database);
teamService = TeamService.GetInstance(database);
measurementService = MeasurementService.GetInstance(database);
featureCategoryService = FeatureCategoryService.GetInstance(database);
}
/// <summary>
/// Load your modules or register your services here!
/// </summary>
/// <param name="kernel">The kernel.</param>
private static void RegisterServices(IKernel kernel)
{
var scoreCalculator = new EloCalculator();
var scoreQuery = new ScoreQuery(new WebSignaler(), scoreCalculator);
var eventBus = new DomainBus();
var teamService = new TeamService();
eventBus.RegisterHandler(() => new GameHandler(scoreQuery));
eventBus.RegisterHandler(() => teamService);
kernel.Bind<IScoreQuery>().ToConstant(scoreQuery);
kernel.Bind<ITeamService>().ToConstant(teamService);
var eventStorage = GetEventStorage(eventBus);
var sessionFactory = new SessionFactory(eventStorage);
kernel.Bind<IEventStorage>().ToConstant(eventStorage);
kernel.Bind<ISessionFactory>().ToConstant(sessionFactory);
var gameService = new GameService(sessionFactory, eventBus);
var commandbus = new DomainBus();
commandbus.RegisterHandler(() => gameService);
kernel.Bind<IBus>().ToConstant(commandbus);
}
public void GetTeam_Success_Test()
{
// Arrange
int id = 1;
R_Team team = SampleTeam(id);
// create mock for repository
var mock = new Mock <ITeamRepository>();
mock.Setup(s => s.GetTeam(Moq.It.IsAny <int>())).Returns(team);
// service
TeamService teamService = new TeamService();
TeamService.Repository = mock.Object;
// Act
TeamDTO result = teamService.GetTeam(id);
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(1, result.TeamId);
}
public void DeleteTeam_Success_Test()
{
// Arrange
TeamDTO dto = SampleTeamDTO(1);
dto.IsDeleted = false;
// create mock for repository
var mock = new Mock <ITeamRepository>();
mock.Setup(s => s.DeleteTeam(Moq.It.IsAny <R_Team>())).Verifiable();
// service
TeamService teamService = new TeamService();
TeamService.Repository = mock.Object;
// Act
teamService.DeleteTeam(dto);
// Assert
Assert.IsTrue(true);
}
public async void Update()
{
var mock = new ServiceMockFacade <ITeamRepository>();
var model = new ApiTeamRequestModel();
mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Team>())).Returns(Task.FromResult(new Team()));
mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(new Team()));
var service = new TeamService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.TeamModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLTeamMapperMock,
mock.DALMapperMockFactory.DALTeamMapperMock,
mock.BOLMapperMockFactory.BOLChainMapperMock,
mock.DALMapperMockFactory.DALChainMapperMock,
mock.BOLMapperMockFactory.BOLMachineRefTeamMapperMock,
mock.DALMapperMockFactory.DALMachineRefTeamMapperMock);
UpdateResponse <ApiTeamResponseModel> response = await service.Update(default(int), model);
response.Should().NotBeNull();
mock.ModelValidatorMockFactory.TeamModelValidatorMock.Verify(x => x.ValidateUpdateAsync(It.IsAny <int>(), It.IsAny <ApiTeamRequestModel>()));
mock.RepositoryMock.Verify(x => x.Update(It.IsAny <Team>()));
}
public async Task TotalAsyncShouldReturnTeamsCount()
{
// Arrage
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext.AddRangeAsync(
new Team { Id = 1 },
new Team { Id = 2 },
new Team { Id = 3 });
await dbContext.SaveChangesAsync();
var teamService = new TeamService(dbContext, mapper);
// Act
var result = await teamService.TotalAsync();
// Assert
result
.Should()
.Be(3);
}
public async Task <ActionResult> Index(GameResult?gameResult, string OppTeamName, string gameTime, int dataSort = -1)
{
List <Game> games;
if (gameResult != null && dataSort != null)
{
games = await GameService.sharedInstance().SortGames((int)dataSort, gameResult);
}
else
{
games = await GameService.sharedInstance().getGames();
}
games = await GameService.sharedInstance().GameAgainstTeam(OppTeamName, games);
games = await GameService.sharedInstance().GetGameByTime(gameTime, games);
ViewBag.teams = await TeamService.sharedInstance().getTeams();
ViewBag.results = new List <GameResult> {
GameResult.Victory, GameResult.Draw, GameResult.Defeat, GameResult.NC
};
return(View(games));
}
public object Photo([FromHeader(Name = "Photo-Year")] string year, [FromForm(Name = "photo")] IFormFile file, int id)
{
if (_context.Teams.Find(id) != null && year != null && TeamService.PhotoSave(file).Result)
{
_context.TeamPhotos.Add(new TeamPhoto()
{
Path = file.FileName, TeamId = id, Year = int.Parse(year)
});
if (_context.SaveChanges() != 0)
{
return(StatusCode(200));
}
else
{
TeamService.PhotoRemove(file.FileName);
return(StatusCode(418));
}
}
else
{
return(StatusCode(418));
}
}
public void TeamService_Search_NewerThan_Invalid()
{
var mockTeams = GetMockTeams();
var mockTeamRepo = new MockTeamRepository().MockGetForLeague(mockTeams);
var mockLeagueRepo = new MockLeagueRepository().MockIsValid(true);
var teamService = new TeamService(mockTeamRepo.Object, mockLeagueRepo.Object);
var searchParams = new TeamSearch()
{
LeagueID = 1,
FoundingDate = new DateTime(2017, 1, 1),
Direction = SearchDateDirection.NewerThan
};
//Act
var results = teamService.Search(searchParams);
Assert.Empty(results);
mockLeagueRepo.VerifyIsValid(Times.Once());
mockTeamRepo.VerifyGetForLeague(Times.Once());
}
public void Test_TeamMembersStepStatus_ParticipantHasHighestScoreIfStepsAreSame()
{
var team = TestData.CreateTeamWithHighestStepper();
team.Participants.ElementAt(1).Steps.First().StepCount = team.Participants.ElementAt(0).Steps.First().StepCount;
var teamService = new TeamService(GetMockStepContext(team));
var result = teamService.GetTeamScoreBoard(1);
var actualOne = false;
var actualTwo = false;
var participantOne = result.First().ParticipantsStepsStatus.SingleOrDefault(p => p.ParticipantId == 1);
var participantTwo = result.First().ParticipantsStepsStatus.SingleOrDefault(p => p.ParticipantId == 1);
if (participantOne != null && participantTwo != null)
{
actualOne = participantOne.ParticipantHighestStepper;
actualTwo = participantTwo.ParticipantHighestStepper;
}
Assert.IsTrue(actualOne && actualTwo, $"Expected participants to both have highest step status of True but got {actualOne} & {actualTwo}");
}
public void ReturnAndCreateTeam()
{
//Arrange
var playerService = new Mock <IPlayerService>();
var options = TestUtils.GetOptions(nameof(ReturnAndCreateTeam));
var teamName = "Cunami";
var teamCity = "Sofia";
var country = "Bulgaria";
var owner = "Hristo Konov";
//Act,Assert
using (var arrangeContext = new FMDbContext(options))
{
var sut = new TeamService(arrangeContext, playerService.Object);
var team = sut.CreateTeam(teamName, teamCity, country, owner);
Assert.AreEqual(team.Name, teamName);
Assert.AreEqual(team.City, teamCity);
Assert.AreEqual(team.Country, country);
Assert.AreEqual(team.Owner, owner);
Assert.AreEqual(1, arrangeContext.Teams.Count());
}
}
public void Throws_TeamDoesntHaveMoneyToBuyPlayer()
{
//Arrange
var teamName = "Cunami";
var teamCity = "Sofia";
var firstName = "Hristo";
var lastName = "Konov";
var playerService = new Mock <IPlayerService>();
var player = new Mock <Player>();
player.SetupAllProperties();
player.Object.FirstName = firstName;
player.Object.LastName = lastName;
player.Object.IsDeleted = false;
player.Object.TeamId = null;
player.Object.Price = 20;
var options = TestUtils.GetOptions(nameof(Throws_TeamDoesntHaveMoneyToBuyPlayer));
playerService.Setup(p => p.RetrievePlayer(firstName, lastName)).Returns(player.Object);
using (var arrangeContext = new FMDbContext(options))
{
arrangeContext.Teams.Add(new Team()
{
Name = teamName, City = teamCity, Budget = 0
});
arrangeContext.SaveChanges();
}
//Act,Assert
using (var assertContext = new FMDbContext(options))
{
var sut = new TeamService(assertContext, playerService.Object);
var ex = Assert.ThrowsException <ArgumentOutOfRangeException>(() => sut.BuyPlayer(teamName, teamCity, firstName, lastName));
Assert.AreEqual(ex.ParamName, $"Team doesn't have enogh money to buy {firstName} {lastName}");
}
}
/// <summary>
/// Run the code example.
/// </summary>
/// <param name="user">The DFP user object running the code example.</param>
public override void Run(DfpUser user)
{
// Get the TeamService.
TeamService teamService = (TeamService)user.GetService(DfpService.v201505.TeamService);
try {
// Create an array to store local team objects.
Team[] teams = new Team[5];
for (int i = 0; i < 5; i++)
{
Team team = new Team();
team.name = "Team #" + i;
team.hasAllCompanies = false;
team.hasAllInventory = false;
teams[i] = team;
}
// Create the teams on the server.
teams = teamService.createTeams(teams);
if (teams != null && teams.Length > 0)
{
foreach (Team newTeam in teams)
{
Console.WriteLine("A team with ID \"{0}\", and name \"{1}\" was created.",
newTeam.id, newTeam.name);
}
}
else
{
Console.WriteLine("No teams created.");
}
} catch (Exception e) {
Console.WriteLine("Failed to create teams. Exception says \"{0}\"", e.Message);
}
}
public ActionResult Edit(int teamId)
{
int Employee_Id = SessionUser.GetUser().Id;
D.Team Team = TeamService.GetTeamById(teamId);
D.Employee TeamLeader = EmployeeService.Get((int)TeamService.GetTeamLeaderId(teamId));
EditForm form = new EditForm()
{
Id = (int)Team.Id,
Name = Team.Name,
SelectedTeamLeaderId = (int)TeamLeader.Employee_Id,
CreatorId = Team.Creator_Id
};
IEnumerable <D.Employee> Employees = EmployeeService.GetAllActive();
List <SelectListItem> TeamLeaderCandidates = new List <SelectListItem>();
foreach (D.Employee emp in Employees)
{
TeamLeaderCandidates.Add(new SelectListItem()
{
Text = emp.FirstName + " " + emp.LastName + " (" + emp.Email + ")",
Value = emp.Employee_Id.ToString()
});
}
// si le TeamLeader actuel est desactivé
if (!Employees.Any(emp => emp.Employee_Id == TeamLeader.Employee_Id))
{
TeamLeaderCandidates.Add(new SelectListItem()
{
Text = "!!!VIRÉ!!! " + TeamLeader.FirstName + " " + TeamLeader.LastName + " (" + TeamLeader.Email + ")",
Value = TeamLeader.Employee_Id.ToString()
});
}
form.TeamLeaderCandidateList = TeamLeaderCandidates;
return(View(form));
}
public void ThrowArgumentException_WhenNewTeamNameIsAlreadyTaken()
{
// arrange
var teamsRepo = new Mock <IEfRepository <Team> >();
var leaguesRepo = new Mock <IEfRepository <League> >();
var firstLeague = new League()
{
Name = "someName"
};
var secondLeague = new League()
{
Name = "otherName"
};
var teams = new List <Team>()
{
new Team()
{
Id = Guid.NewGuid(), Name = "Team1", League = firstLeague
},
new Team()
{
Id = Guid.NewGuid(), Name = "Team2", League = secondLeague
},
new Team()
{
Id = Guid.NewGuid(), Name = "Team3", League = firstLeague
},
};
teamsRepo.Setup(t => t.All).Returns(teams.AsQueryable());
var teamService = new TeamService(teamsRepo.Object, leaguesRepo.Object);
// act & assert
Assert.Throws <ArgumentException>(() => teamService.Update(teams[0].Id, "Team2", "logo"));
}
public string Execute(string[] inputArgs)
{
//CreateTeam <name> <acronym> <description>
AuthenticationManager.Authorize();
if (inputArgs.Length != 2 && inputArgs.Length != 3)
{
throw new ArgumentOutOfRangeException(nameof(inputArgs));
}
string teamName = inputArgs[0];
if (teamName.Length > 25)
{
throw new ArgumentException(string.Format(Constants.ErrorMessages.InvalidTeamName, teamName));
}
if (CommandHelper.IsTeamExisting(teamName))
{
throw new ArgumentException(string.Format(Constants.ErrorMessages.TeamExists, teamName));
}
string acronym = inputArgs[1];
if (acronym.Length != 3)
{
throw new ArgumentException(string.Format(Constants.ErrorMessages.InvalidAcronym, acronym));
}
string description = inputArgs.Length == 3 ? inputArgs[2] : null;
TeamService.AddTeam(teamName, acronym, description);
return($"Team {teamName} successfully created!");
}
// GET: Project/Details/5
public ActionResult Details(int id)
{
ProjectViewModel PVM = new ProjectViewModel();
var pip = ps.GetById(id);
PVM.ProjectId = pip.ProjectId;
PVM.ProjectName = pip.ProjectName;
PVM.Start_Date = pip.Start_Date;
PVM.End_Date = pip.End_Date;
PVM.Duration = pip.Duration;
PVM.etat = (Web.Models.Etat)pip.etat;
//---------------------------------------
PVM.Description = pip.Description;
var currentUserId = User.Identity.GetUserId();
int myInt = int.Parse(currentUserId);
User teamlead = us.GetById(myInt);
//---------------------------------------
TeamService teamservice = new TeamService();
Team t = teamservice.GetById(teamlead.TeamFK);
//--------------------------------------------
float progress = TS.ProjectProgress(id);
var T = TS.GetAll().Where(e => e.ProjectFK == id);
Console.WriteLine(T);
List <Tasks> tasks = T.ToList();
ViewData["Tasks"] = tasks;
ViewData["TeamLead"] = teamlead;
ViewData["Team"] = t;
ViewData["Progress"] = progress;
return(View(PVM));
}
public void GetActive_PuzzelID_NotexistingTeam()
{
var spelerMock = new Mock <ISpelerRepository>();
var sessieMock = new Mock <ISessionRepository>();
var teamMock = new Mock <ITeamRepository>();
var puzzelMock = new Mock <IPuzzelRepository>();
teamMock.Setup(t => t.GetTeams()).Returns(_fakeTeamRepo.GetTeams());
teamMock.Setup(t => t.GetTeam(It.IsIn(1, 2))).Returns((int i) => _fakeTeamRepo.GetTeam(i));
teamMock.Setup(t => t.GetTeam(It.IsNotIn(1, 2))).Returns((Team)null);
puzzelMock.Setup(p => p.GetPuzzel(It.IsAny <int>())).Returns(new Puzzel());
var team = new TeamService(teamMock.Object,
spelerMock.Object,
sessieMock.Object,
puzzelMock.Object);
//Arrange
var teamId = 99999;
// Act
var result = team.ActivePuzzelID(teamId);
// Assert
Assert.Equal(-1, result);
}
public void Get_ScorePosition_NotTeamInSession()
{
var spelerMock = new Mock <ISpelerRepository>();
var sessieMock = new Mock <ISessionRepository>();
var teamMock = new Mock <ITeamRepository>();
var puzzelMock = new Mock <IPuzzelRepository>();
teamMock.Setup(t => t.GetTeams()).Returns(_fakeTeamRepo.GetTeams());
teamMock.Setup(t => t.GetTeam(1)).Returns(_fakeTeamRepo.GetTeam(1));
teamMock.Setup(t => t.GetTeam(It.IsNotIn(1))).Returns((Team)null);
sessieMock.Setup(s => s.GetSessie(1)).Returns(_fakeSessieRepo.GetSessie(1));
var team = new TeamService(teamMock.Object,
spelerMock.Object,
sessieMock.Object,
puzzelMock.Object);
//Arrange
var teamId = 5;
// Act
int result = team.GetScorePos(teamId);
// Assert
Assert.Equal(-1, result);
}
public ActionResult DelEmployee(int id, TeamDelEmployee collection)
{
try
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
EmployeeService employeeRepo = new EmployeeService();
CD.Employee employee = employeeRepo.Get().Where <CD.Employee>(emp => emp.Email == collection.Email).SingleOrDefault();
if (employee != null)
{
TeamService r = new TeamService();
if (r.AddEmployee(employee.Id, id)) //<<----------------Merci, j'ai bien rit ;)
{
return(RedirectToAction("Details", new { id = id }));
}
else
{
return(View(collection));
}
}
else
{
return(View(collection));
}
}
else
{
return(View(collection));
}
}
catch
{
return(View(collection));
}
}
public async void Delete_ErrorsOccurred_ShouldReturnErrorResponse()
{
var mock = new ServiceMockFacade <ITeamService, ITeamRepository>();
var model = new ApiTeamServerRequestModel();
var validatorMock = new Mock <IApiTeamServerRequestModelValidator>();
validatorMock.Setup(x => x.ValidateDeleteAsync(It.IsAny <int>())).Returns(Task.FromResult(new FluentValidation.Results.ValidationResult(new List <ValidationFailure>()
{
new ValidationFailure("text", "test")
})));
var service = new TeamService(mock.LoggerMock.Object,
mock.MediatorMock.Object,
mock.RepositoryMock.Object,
validatorMock.Object,
mock.DALMapperMockFactory.DALTeamMapperMock,
mock.DALMapperMockFactory.DALChainMapperMock);
ActionResponse response = await service.Delete(default(int));
response.Should().NotBeNull();
response.Success.Should().BeFalse();
validatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <int>()));
mock.MediatorMock.Verify(x => x.Publish(It.IsAny <TeamDeletedNotification>(), It.IsAny <CancellationToken>()), Times.Never());
}
public UserControl_Begin(UserControl_MainContent mainContent)
{
InitializeComponent();
new Thread(() =>
{
UtilsNotification.StartLoadingAnimation();
_mainContent = mainContent;
seasonService = new SeasonService();
competitionService = new CompetitionService();
teamService = new TeamService();
matchService = new MatchService();
Thread.Sleep(1000);
TextBoxNSeasons.Dispatcher.BeginInvoke((Action)(() => TextBoxNSeasons.Text = seasonService.GetSeasonsNumber().ToString()));
TextBoxNCompetitions.Dispatcher.BeginInvoke((Action)(() => TextBoxNCompetitions.Text = competitionService.GetCompetitionsNumber().ToString()));
TextBoxNTeams.Dispatcher.BeginInvoke((Action)(() => TextBoxNTeams.Text = teamService.GetTeamsNumber().ToString()));
TextBoxNMatches.Dispatcher.BeginInvoke((Action)(() => TextBoxNMatches.Text = matchService.GetMatchesNumber().ToString()));
UtilsNotification.StopLoadingAnimation();
}).Start();
}
public string Execute(string[] inputArgs)
{
Check.CheckLength(2, inputArgs);
AuthenticationManager.Authorize();
string eventName = inputArgs[0];
if (!CommandHelper.IsEventExisting(eventName))
{
throw new ArgumentException(string.Format(Constants.ErrorMessages.EventNotFound, eventName));
}
string teamName = inputArgs[1];
if (!CommandHelper.IsTeamExisting(teamName))
{
throw new ArgumentException(string.Format(Constants.ErrorMessages.TeamNotFound, teamName));
}
var currentUser = AuthenticationManager.GetCurrentUser();
var ev = EventService.GetEvent(eventName);
if (currentUser.Username != ev.Creator.Username)
{
throw new InvalidOperationException(Constants.ErrorMessages.NotAllowed);
}
var team = TeamService.GetTeam(teamName);
if (ev.ParticipatingTeams.Contains(team))
{
throw new InvalidOperationException(Constants.ErrorMessages.TeamExists);
}
return($"Team {teamName} added for {eventName}");
}
public void Throws_PlayerAlreadyHasTeam()
{
//Arrange
var teamName = "Cunami";
var teamCity = "Sofia";
var firstName = "Hristo";
var lastName = "Konov";
var playerService = new Mock <IPlayerService>();
var player = new Mock <Player>();
player.SetupAllProperties();
player.Object.FirstName = firstName;
player.Object.LastName = lastName;
player.Object.IsDeleted = false;
player.Object.TeamId = 1;
var options = TestUtils.GetOptions(nameof(Throws_PlayerAlreadyHasTeam));
playerService.Setup(p => p.RetrievePlayer(firstName, lastName)).Returns(player.Object);
using (var arrangeContext = new FMDbContext(options))
{
arrangeContext.Teams.Add(new Team()
{
Name = teamName, City = teamCity
});
arrangeContext.SaveChanges();
}
//Act,Assert
using (var assertContext = new FMDbContext(options))
{
var sut = new TeamService(assertContext, playerService.Object);
var ex = Assert.ThrowsException <EntityAlreadyExistsException>(() => sut.BuyPlayer(teamName, teamCity, firstName, lastName));
Assert.AreEqual(ex.Message, "Player already has a team");
}
}
public ActionResult EmployeesInTeam(int teamId)
{
int Employee_Id = SessionUser.GetUser().Id;
D.Team Team = TeamService.GetTeamById(teamId);
IEnumerable <D.Employee> Employees = EmployeeService.GetAllActive();
IEnumerable <D.Employee> EmployeesInTeam = TeamService.GetAllEmployeesForTeam(teamId);
List <EmployeeTeamSelector> EmployeesInTeamFormList = new List <EmployeeTeamSelector>();
foreach (D.Employee employee in Employees)
{
IEnumerable <D.Department> departments = DepartmentService.GetEmployeeActiveDepartments((int)employee.Employee_Id);
EmployeesInTeamFormList.Add(new EmployeeTeamSelector
{
Team = Team,
Employee = employee,
Departments = departments,
IsInTeam = EmployeesInTeam.Any(x => x.Employee_Id == employee.Employee_Id)
});
}
return(View(EmployeesInTeamFormList));
}
//• KickMember <teamName> <username>
public string Execute(string[] inputArgs)
{
Check.CheckLength(2, inputArgs);
AuthenticationManager.Authorize();
var currentUser = AuthenticationManager.GetCurrentUser();
var teamName = inputArgs[0];
var username = inputArgs[1];
if (!CommandHelper.IsTeamExisting(teamName))
{
throw new ArgumentException(string.Format(Constants.ErrorMessages.TeamNotFound, teamName));
}
if (!CommandHelper.IsUserExisting(username))
{
throw new ArgumentException(string.Format(Constants.ErrorMessages.UserNotFound, username));
}
if (CommandHelper.IsUserCreatorOfTeam(teamName, username))
{
throw new ArgumentException(Constants.ErrorMessages.NotAllowed);
}
//when trying to kick themselves
if (currentUser.Username == username)
{
throw new InvalidOperationException(string.Format(Constants.ErrorMessages.CommandNotAllowed,
"DisbandTeam"));
}
TeamService.KickMemberFromTeam(teamName, username);
return($"User {username} has been kicked from {teamName} by {currentUser.Username}");
}
public UserControl_Matches(UserControl_MainContent mainContent)
{
InitializeComponent();
new Thread(() =>
{
UtilsNotification.StartLoadingAnimation();
_mainContent = mainContent;
typeMatchView = MatchViewTypeValues.AttackDefense;
ImageLogo.Dispatcher.BeginInvoke((Action)(() => ImageLogo.Visibility = Visibility.Visible));
LabelInfo.Dispatcher.BeginInvoke((Action)(() => LabelInfo.Visibility = Visibility.Visible));
LabelExtraInfo.Dispatcher.BeginInvoke((Action)(() => LabelExtraInfo.Visibility = Visibility.Visible));
teamService = new TeamService();
matchService = new MatchService();
IsDrawableMenuOpen = false;
DrawableMenuContainer.Dispatcher.BeginInvoke((Action)(() =>
DrawableMenuContainer.Content = new UserControl_DrawableMenuMatches(_mainContent, this)));
UtilsNotification.StopLoadingAnimation();
}).Start();
}
public async Task GetFreeTeamByCityIdAsyncShouldWorkCorrectly()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var teamRepo = new EfDeletableEntityRepository <Team>(dbContext);
var employeeRepo = new EfDeletableEntityRepository <ApplicationUser>(dbContext);
var service = new TeamService(teamRepo, employeeRepo);
await teamRepo.AddAsync(new Team());
await teamRepo.AddAsync(new Team
{
CityId = 10,
});
await teamRepo.SaveChangesAsync();
var team = await service.GetFreeTeamByCityIdAsync <TeamModel>(10);
Assert.Equal(10, team.CityId);
}
public async Task AddEmployeeAsyncShouldWorkCorrectly()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var teamRepo = new EfDeletableEntityRepository <Team>(dbContext);
var employeeRepo = new EfDeletableEntityRepository <ApplicationUser>(dbContext);
var service = new TeamService(teamRepo, employeeRepo);
var employeeId = Guid.NewGuid().ToString();
var teamId = 1;
await teamRepo.AddAsync(new Team());
await teamRepo.SaveChangesAsync();
await employeeRepo.AddAsync(new ApplicationUser
{
Id = employeeId,
});
await employeeRepo.SaveChangesAsync();
await service.AddEmployeeAsync(teamId, employeeId);
var team = await teamRepo.All()
.FirstOrDefaultAsync();
var employee = await employeeRepo.All()
.FirstOrDefaultAsync();
Assert.Contains(team.Employees, x => x.Id == employeeId);
Assert.Equal(teamId, team.Id);
}
public async void TeamService_CreateTeamAsync_ReturnsIdFromRepoCall()
{
// arrange
TeamDto dto = new TeamDto
{
Name = "The Mighty Ducks",
Zip = "38655",
};
int newTeamId = 32;
var repo = new Mock <IRepository>();
repo.Setup(r => r.CreateTeamAsync(dto.Name, dto.Zip)).ReturnsAsync(newTeamId);
repo.Setup(r => r.TeamNameExistsAsync(dto.Name)).ReturnsAsync(false);
var target = new TeamService(repo.Object);
// act
var result = await target.CreateTeamAsync(1, dto);
// assert
Assert.Equal(newTeamId, result.Id);
}
public ActionResult Index()
{
int Employee_Id = SessionUser.GetUser().Id;
IEnumerable <D.Team> Teams = TeamService.GetAllActiveTeamsForEmployee(Employee_Id);
List <ProjectTeamsForm> ProjectTeamList = new List <ProjectTeamsForm>();
foreach (D.Team team in Teams)
{
ProjectTeamsForm element = ProjectTeamList.Where(pt => pt.Project.Id == team.Project_Id).FirstOrDefault();
if (element is null)
{
ProjectTeamsForm NewElement = new ProjectTeamsForm
{
Project = ProjectService.GetProjectById(team.Project_Id),
Teams = new List <D.Team>()
};
NewElement.Teams.Add(team);
ProjectTeamList.Add(NewElement);
}
else
{
element.Teams.Add(team);
}
}
IEnumerable <D.Department> MyDepartments = DepartmentService.GetEmployeeDepartments(Employee_Id);
IndexForm form = new IndexForm
{
ProjectTeamList = ProjectTeamList,
MyDepartments = DepartmentService.GetEmployeeActiveDepartments(Employee_Id),
ProjectManagerProjects = ProjectService.GetActiveProjectsForManager(Employee_Id),
TeamLeaderTeams = TeamService.GetActiveTeamsForTeamLeader(Employee_Id),
HeadOfDepartmentDepartments = DepartmentService.GetHeadOfDepartmentActiveDepartments(Employee_Id)
};
return(View(form));
}
public ActionResult Create(MatchCreateViewModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
var creator = _db.Players.First(p => p.AccountEmail == User.Identity.Name);
var redTeam = TeamService.Get(_db, model.RedOneId, model.RedTwoId);
var blueTeam = TeamService.Get(_db, model.BlueOneId, model.BlueTwoId);
var table = _db.Tables.Find(model.TableId);
var match = new Match
{
BlueTeam = blueTeam,
RedTeam = redTeam,
Table = table,
StartTime = DateTime.Now,
Creator = creator
};
_db.Matches.Add(match);
_db.SaveChanges();
return(RedirectToAction("Details", "Matches", new { id = match.Id }));
}
public void SetUp()
{
wrapperService = new Mock<IDataAccessWrapperService>();
teamService = new TeamService(wrapperService.Object);
}
public TeamsController(TeamService teamService)
{
this.teamService = teamService;
}
public void GetUserIdAndInsertMember( string name, Guid userId )
{
var m = new Member
{
Name = name,
Surname = string.Empty,
UserID = userId
};
var teamService = new TeamService();
teamService.InsertMember( m );
}
