Exemplo n.º 1
0
 public SelectionViewModel(IList<Team> teams1, IList<Team> teams2, IList<Division> divisions, Team team1 = null, Team team2 = null, Division division1 = null, Division division2 = null)
 {
     Team1List = new SelectList(teams1, "Id", "FullName", team1 != null ? team1.Id.ToString() : string.Empty);
     Team2List = new SelectList(teams2, "Id", "FullName", team2 != null ? team2.Id.ToString() : string.Empty);
     Division1List = new SelectList(divisions, "Id", "Name", division1 != null ? division1.Id.ToString() : string.Empty);
     Division2List = new SelectList(divisions, "Id", "Name", division2 != null ? division2.Id.ToString() : string.Empty);
 }
        public void TestAlreadyExists()
        {
            _db  = new Data.Entities.HLContext();
            test = new Data.RankRepository(_db);
            Data.TeamRepository teamrepo = new Data.TeamRepository(_db);
            Domain.Team         team     = new Domain.Team();
            team.teamname = "testteam123";
            teamrepo.AddTeam(team);
            _db.SaveChanges();

            int gameid = 1;

            Domain.Team newteam = teamrepo.GetByTeamName("testteam123");
            Domain.Rank rank    = new Domain.Rank(newteam, gameid);

            //still working on this part
            // Rank testrank = _db.Rank.Where(x => x.)

            test.DeleteRank(rank);
            bool exists = test.AlreadyExists(rank);

            // should not already exist, since it was never added to the database
            Assert.AreEqual(exists, false);

            //changed team to newteam so it matches the code
            teamrepo.DeleteTeam(newteam);
            _db.SaveChanges();
        }
Exemplo n.º 3
0
 public void Put(Team input)
 {
     input.ValidateNotNullParameter("team input");
     this.Name = input.Name;
     this.TeamMembers = input.TeamMembers;
     this.Expertise = input.Expertise;
 }
        public void TestInitializeRanks()
        {
            _db  = new Data.Entities.HLContext();
            test = new Data.RankRepository(_db);
            Data.TeamRepository teamrepo = new Data.TeamRepository(_db);
            Domain.Team         team     = new Domain.Team();
            team.teamname = "testteam";
            teamrepo.AddTeam(team);
            _db.SaveChanges();

            Domain.Team newteam = teamrepo.GetByTeamName("testteam");

            bool initialized = test.InitializeRanks(newteam);

            Assert.AreEqual(initialized, true);
            bool repeateinit = test.InitializeRanks(newteam);

            Assert.AreEqual(repeateinit, false);

            var ranklist = test.GetRanksByTeam("testteam");

            foreach (var rank in ranklist)
            {
                test.DeleteRank(rank);
            }

            teamrepo.DeleteTeam(newteam);
            _db.SaveChanges();
        }
        public IActionResult getbyteamname(string teamname)
        {
            Domain.Team thisTeam = new Domain.Team();
            thisTeam = _TeamRepository.GetByTeamName(teamname);

            if (thisTeam == null)
            {
                return(BadRequest(new { message = "Team does not exist." }));
            }


            return(Ok(thisTeam));
        }
        public void TestMapDomainToData()
        {
            Domain.Team team1 = new Domain.Team();
            team1.id = 500;
            int gamemode = 1;

            Domain.Rank domrank = new Domain.Rank(team1, gamemode);

            Data.Entities.Rank datrank = Data.Mapper.Map(domrank);

            Assert.AreEqual(datrank.Teamid, 500);
            Assert.AreEqual(datrank.Gamemodeid, 1);
        }
 public static Dmn.Team ToNewDmn(Dto.Team dataObject)
 {
     Dmn.EarlyBirdsContext context = new Dmn.EarlyBirdsContext();
     Dmn.Team output = new Dmn.Team(dataObject.Name);
     if (dataObject.TeamMemberIds != null)
     {
         output.AddTeamMembers(context.Agents.Where(i => dataObject.TeamMemberIds.Contains(i.Id)));
     }
     if (dataObject.Expertise != null)
     {
         foreach (Dmn.TypeOfIssue field in dataObject.Expertise)
         {
             output.Expertise.Add(field);
         }
     }
     return output;
 }
        public IActionResult CreateTeam([FromBody] Models.TeamInputModel team)
        {
            string outMessage = "";

            if (ValidateTeamInput(team, out outMessage) == false)
            {
                return(BadRequest(new { message = outMessage }));
            }

            var user1 = _UserRepository.GetUserByUsername(team.username);

            if (user1 == null)
            {
                return(BadRequest(new { message = "User does not exist." }));
            }

            Domain.Team team1 = new Domain.Team(user1);
            team1.teamname = team.teamname;
            bool validated = _TeamRepository.AddTeam(team1);

            if (!validated)
            {
                return(StatusCode(500));
            }

            Domain.Team madeTeam  = _TeamRepository.GetByTeamName(team1.teamname);
            bool        ranksMade = false;

            ranksMade = _RankRepository.InitializeRanks(madeTeam);
            if (!ranksMade)
            {
                _TeamRepository.DeleteTeam(madeTeam);
                return(StatusCode(500));
            }

            foreach (var user in madeTeam.Userlist)
            {
                user.password = null;
            }

            return(Created("app/team/create", madeTeam));
        }
        public void TestGetRanksByMode()
        {
            _db  = new Data.Entities.HLContext();
            test = new Data.RankRepository(_db);
            Data.TeamRepository teamrepo = new Data.TeamRepository(_db);
            Domain.Team         team1    = new Domain.Team();
            Domain.Team         team2    = new Domain.Team();
            team1.teamname = "team1";
            team2.teamname = "team2";
            teamrepo.AddTeam(team1);
            teamrepo.AddTeam(team2);
            _db.SaveChanges();

            Domain.Team newteam1 = teamrepo.GetByTeamName("team1");
            Domain.Team newteam2 = teamrepo.GetByTeamName("team2");

            test.InitializeRanks(newteam1);
            test.InitializeRanks(newteam2);

            var rankmodelist = test.GetRanksByMode(1);

            //Check that two ranks are returned (one for each of the two teams)
            Assert.AreEqual(2, rankmodelist.Count);

            var ranklist = test.GetRanksByTeam("team1");

            foreach (var rank in ranklist)
            {
                test.DeleteRank(rank);
            }
            ranklist = test.GetRanksByTeam("team2");
            foreach (var rank in ranklist)
            {
                test.DeleteRank(rank);
            }

            teamrepo.DeleteTeam(newteam1);
            teamrepo.DeleteTeam(newteam2);
            _db.SaveChanges();
        }
        public void TestUpdateRank()
        {
            _db  = new Data.Entities.HLContext();
            test = new Data.RankRepository(_db);
            Data.TeamRepository teamrepo = new Data.TeamRepository(_db);
            Domain.Team         team     = new Domain.Team();
            team.teamname = "testteam";
            teamrepo.AddTeam(team);
            _db.SaveChanges();

            int gameid = 1;

            Domain.Team newteam = teamrepo.GetByTeamName("testteam");
            Domain.Rank rank    = new Domain.Rank(newteam, gameid);
            Domain.Rank rank2   = new Domain.Rank(newteam, 2);

            test.AddRank(rank);
            test.Save();

            bool updatenotexist = test.UpdateRank(rank2);

            //should be false, because rank is not in database so cannot be updated
            Assert.AreEqual(false, updatenotexist);

            var  newrank = test.GetRank("testteam", 1);
            bool update  = test.UpdateRank(newrank);

            Assert.AreEqual(true, update);


            newrank.AddWin();
            test.UpdateRank(newrank);
            var uprank = test.GetRank("testteam", 1);

            Assert.AreEqual(uprank.wins, 1);

            test.DeleteRank(newrank);
            teamrepo.DeleteTeam(newteam);
            _db.SaveChanges();
        }
Exemplo n.º 11
0
        public static Domain.Team Map(Data.Entities.Team deTeam)
        {
            Domain.Team dmTeam = new Domain.Team();
            dmTeam.id       = deTeam.Id;
            dmTeam.teamname = deTeam.Teamname;
            int i = 0;

            foreach (var item in deTeam.UserTeam)
            {
                dmTeam.Roles.Add(item.Leader);
                dmTeam.Userlist.Add(Map(item.User));
                i += 1;
            }

            foreach (var item in deTeam.Rank)
            {
                dmTeam.rank.Add(item.Rank1);
            }


            return(dmTeam);
        }
        public void TestAddAndDeleteRank()
        {
            _db  = new Data.Entities.HLContext();
            test = new Data.RankRepository(_db);
            Data.TeamRepository teamrepo = new Data.TeamRepository(_db);
            Domain.Team         team     = new Domain.Team();
            team.teamname = "testteam123";
            teamrepo.AddTeam(team);
            _db.SaveChanges();

            int gameid = 1;

            Domain.Team newteam = teamrepo.GetByTeamName("testteam123");
            Domain.Rank rank    = new Domain.Rank(newteam, gameid);

            bool add = test.AddRank(rank);

            test.Save();
            Assert.AreEqual(add, true);
            bool repeateadd = test.AddRank(rank);

            test.Save();
            Assert.AreEqual(repeateadd, false);

            Domain.Rank removeRank = test.GetRank("testteam123", 1);
            Assert.IsNotNull(removeRank);

            bool delete = test.DeleteRank(removeRank);

            test.Save();
            Assert.AreEqual(delete, true);
            bool repeatdelete = test.DeleteRank(removeRank);

            test.Save();
            Assert.AreEqual(repeatdelete, false);

            teamrepo.DeleteTeam(newteam);
            _db.SaveChanges();
        }
Exemplo n.º 13
0
        public static Data.Entities.Team Map(Domain.Team dmTeam)
        {
            Data.Entities.Team            deTeam     = new Entities.Team();
            List <Data.Entities.UserTeam> deUserTeam = new List <Entities.UserTeam>();

            if (dmTeam.Userlist.Count > 0 && dmTeam.Userlist.Count == dmTeam.Roles.Count)
            {
                for (int i = 0; i < dmTeam.Userlist.Count; i++)
                {
                    Data.Entities.UserTeam soloUserTeam = new Data.Entities.UserTeam();
                    soloUserTeam.Leader = dmTeam.Roles[i];
                    soloUserTeam.Userid = dmTeam.Userlist[i].id;
                    deUserTeam.Add(soloUserTeam);
                }
            }

            if (dmTeam.id != null)
            {
                deTeam.Id = (int)dmTeam.id;
            }
            deTeam.UserTeam = deUserTeam;
            deTeam.Teamname = dmTeam.teamname;
            return(deTeam);
        }
        public IActionResult ChangeLeader([FromBody] Models.TeamInputModel team)
        {
            string outMessage = "";

            if (ValidateTeamInput(team, out outMessage) == false)
            {
                return(BadRequest(new { message = outMessage }));
            }
            Domain.Team pullTeam  = _TeamRepository.GetByTeamName(team.teamname);
            bool        hasLeader = false;

            for (int i = 0; i < pullTeam.Roles.Count; i++)
            {
                pullTeam.Roles[i] = false;
                if (pullTeam.Userlist[i].username == team.username)
                {
                    pullTeam.Roles[i] = true;
                    hasLeader         = true;
                }
            }

            if (!hasLeader)
            {
                return(BadRequest(new { message = "User is not on the team." }));
            }

            bool success;

            success = _TeamRepository.UpdateTeam(pullTeam);
            if (!success)
            {
                return(StatusCode(500));
            }

            return(Ok());
        }
Exemplo n.º 15
0
        public void AddAndRemoveTeamTest()
        {
            Data.Entities.HLContext _db      = new Data.Entities.HLContext();
            Data.TeamRepository     test     = new Data.TeamRepository(_db);
            Data.UserRepository     usertest = new Data.UserRepository(_db);

            bool success; //variable to determine if a team was added or removed successfully.

            Domain.Team x = new Domain.Team();
            x.teamname = "XXstarstrikersXX1113452435x4";
            success    = test.DeleteTeam(x);
            _db.SaveChanges();
            success = test.AddTeam(x);
            _db.SaveChanges();
            //assert that the team was added to the database
            Assert.AreEqual(success, true);

            success = test.AddTeam(x);
            _db.SaveChanges();
            //assert that the team was not added to the database because it already exists
            Assert.AreEqual(success, false);

            //assert that the team was successfuly deleted from the database
            success = test.DeleteTeam(x);
            _db.SaveChanges();
            Assert.AreEqual(success, true);

            //assert that the team was not deleted from the database because it did not exist
            success = test.DeleteTeam(x);
            _db.SaveChanges();
            Assert.AreEqual(success, false);

            //assert that the propery userteam table was added to the database
            Domain.User anewuser = new Domain.User("newuser89", "newpassword89");
            //delete the user from DB incase it exist
            success = usertest.DeleteUser(anewuser);
            if (success)
            {
                usertest.Save();
            }
            //add the user to the DB
            success = usertest.AddUser(anewuser);
            if (success)
            {
                usertest.Save();
            }

            //pull the user from the database
            Domain.User anewuserwithID = usertest.GetUserByUsername("newuser89");
            //add the user to the team
            x.AddMember(anewuserwithID);
            //add the team to the DB
            success = test.DeleteTeam(x);
            _db.SaveChanges();
            success = test.AddTeam(x);
            _db.SaveChanges();

            //now check that a usertable was created properly for the team
            Data.Entities.UserTeam userteam = _db.UserTeam.Where(jj => jj.Userid == anewuserwithID.id).FirstOrDefault();

            Assert.AreEqual(userteam.Userid, anewuserwithID.id);

            //now remove the team from the db
            success = test.DeleteTeam(x);

            Data.Entities.UserTeam deleted = _db.UserTeam.Where(jj => jj.Userid == anewuserwithID.id).FirstOrDefault();
            //check that the userteam was deleted
            Assert.AreEqual(deleted, null);

            //delete the user from the DB to keep it clean
            usertest.DeleteUser(anewuserwithID);
            usertest.Save();
        }
Exemplo n.º 16
0
        public void UpdateTeamTest()
        {
            Data.Entities.HLContext _db      = new Data.Entities.HLContext();
            Data.TeamRepository     test     = new Data.TeamRepository(_db);
            Data.UserRepository     usertest = new Data.UserRepository(_db);

            //preliminary stuff to clean database in case this stuff is already in there
            //first see if the team used in this test is in the DB
            Data.Entities.Team isthisteamhere = _db.Team.Where(o => o.Teamname.Equals("testteamname")).FirstOrDefault();
            if (isthisteamhere != null)
            {
                //obtain the primary key for this team
                int primarykey = isthisteamhere.Id;
                //remove the userteam(s) associated with this team
                IEnumerable <UserTeam> ww = _db.UserTeam.Where(mm => mm.Teamid == primarykey);
                foreach (var item in ww)
                {
                    _db.UserTeam.Remove(item);
                }
                _db.SaveChanges();
                //now we can remove the team
                _db.Team.Remove(isthisteamhere);
                _db.SaveChanges();
            }

            //now we can remove our user1 and 2 if they exist
            Data.Entities.User isthisuserhere = _db.User.Where(p => p.Username.Equals("username1")).FirstOrDefault();
            if (isthisuserhere != null)
            {
                _db.User.Remove(isthisuserhere);
                _db.SaveChanges();
            }
            Data.Entities.User isthisuserhere2 = _db.User.Where(p => p.Username.Equals("username2")).FirstOrDefault();
            if (isthisuserhere2 != null)
            {
                _db.User.Remove(isthisuserhere2);
                _db.SaveChanges();
            }



            bool what;    //random bool to hold data about success of methods.
            bool success; //initialize boolean for asserts

            //first case, we pass the method a faulty team check for null case and count case.
            Domain.Team team = new Domain.Team();
            success = test.UpdateTeam(team);
            Assert.AreEqual(success, false);



            //second test case for we have an empty team in the database and it is updated to contain a team.
            team.teamname = "testteamname";

            Domain.User user = new Domain.User("username1", "password1");

            //need to add user to db and pull it to get a stupid id
            success = usertest.DeleteUser(user);
            usertest.Save();
            //add user to the database;
            success = usertest.AddUser(user);
            usertest.Save();
            if (!success)
            {
                Assert.Fail();
            }
            _db.SaveChanges();

            //obtain the user from the database so it has the userID
            var x = _db.User.Where(a => a.Username.Equals(user.username)).FirstOrDefault();

            Domain.User user1withID = Mapper.Map(x);

            team.Roles.Add(true);
            team.Userlist.Add(user1withID);

            what = test.DeleteTeam(team);
            what = test.AddTeam(team);

            //now I will add another user to the team and see if it updates.
            Domain.User user2 = new Domain.User("username2", "password2");
            usertest.AddUser(user2);
            usertest.Save();
            var xx = _db.User.Where(a => a.Username.Equals(user2.username)).FirstOrDefault();

            Domain.User user2withID = Mapper.Map(xx);
            team.AddMember(user2withID);

            success = test.UpdateTeam(team);
            Assert.AreEqual(success, true);
            //keep database clean and undo the things i put in it
            //first remove the userteams
            //preliminary stuff to clean database in case this stuff is already in there
            //first see if the team used in this test is in the DB
            Data.Entities.Team isthisteamhere3 = _db.Team.Where(o => o.Teamname.Equals("testteamname")).FirstOrDefault();
            if (isthisteamhere3 != null)
            {
                //obtain the primary key for this team
                int primarykey = isthisteamhere3.Id;
                //remove the userteam(s) associated with this team
                IEnumerable <UserTeam> ww = _db.UserTeam.Where(mm => mm.Teamid == primarykey);
                foreach (var item in ww)
                {
                    _db.UserTeam.Remove(item);
                }
                _db.SaveChanges();
                //now we can remove the team
                _db.Team.Remove(isthisteamhere3);
                _db.SaveChanges();
            }

            //now we can remove our user1 and 2 if they exist
            Data.Entities.User isthisuserhere3 = _db.User.Where(p => p.Username.Equals("username1")).FirstOrDefault();
            if (isthisuserhere3 != null)
            {
                _db.User.Remove(isthisuserhere3);
                _db.SaveChanges();
            }
            Data.Entities.User isthisuserhere4 = _db.User.Where(p => p.Username.Equals("username2")).FirstOrDefault();
            if (isthisuserhere4 != null)
            {
                _db.User.Remove(isthisuserhere4);
                _db.SaveChanges();
            }
        }
Exemplo n.º 17
0
        public void GetByTeamNameTest()
        {
            Data.Entities.HLContext _db      = new Data.Entities.HLContext();
            Data.TeamRepository     test     = new Data.TeamRepository(_db);
            Data.UserRepository     usertest = new Data.UserRepository(_db);
            bool success;



            Domain.Team miteam = new Domain.Team();
            miteam.teamname = "grisaia";
            Domain.User user1 = new Domain.User("username1", "password1");

            /*
             * //get team id for next query
             * Data.Entities.Team ii = _db.Team.Where(ss => ss.Teamname.Equals("grisaia")).FirstOrDefault();
             * //first remove all userteams associated with this team
             * IEnumerable<Data.Entities.UserTeam> grisaiausers = _db.UserTeam.Where(a => a.Teamid == ii.Id);
             * _db.SaveChanges();
             * if (grisaiausers.GetEnumerator()!=null)
             * {
             *  foreach (var item in grisaiausers)
             *  {
             *      _db.UserTeam.Remove(item);
             *
             *  }
             *  _db.SaveChanges();
             *
             *
             * }
             */

            //remove user from db if it exist
            success = usertest.DeleteUser(user1);
            usertest.Save();
            //add user to the database;
            success = usertest.AddUser(user1);
            usertest.Save();
            if (!success)
            {
                Assert.Fail();
            }
            _db.SaveChanges();

            //obtain the user from the database so it has the userID
            var x = _db.User.Where(a => a.Username.Equals(user1.username)).FirstOrDefault();

            Domain.User user1withID = Mapper.Map(x);

            miteam.Userlist.Add(user1withID);
            miteam.Roles.Add(true);

            //remove team from db if it exist
            success = test.DeleteTeam(miteam);
            //add team to database
            success = test.AddTeam(miteam);



            //obtain the team from the database so it has a teamID
            var y = _db.Team.Where(gg => gg.Teamname.Equals(miteam.teamname)).FirstOrDefault();

            Domain.Team miteamwithID = Mapper.Map(y);
            miteamwithID.Userlist.Add(user1withID);
            miteamwithID.Roles.Add(true);

            //create the userteam entity from the above.
            IEnumerable <Data.Entities.UserTeam> userteam = Mapper.Map(miteam).UserTeam;



            Domain.Team newteam = test.GetByTeamName("grisaia");



            Assert.AreEqual(newteam.Userlist.Count, miteam.Userlist.Count);
            Assert.AreEqual(newteam.Roles.Count, miteam.Roles.Count);

            //remove stuffs from database.


            //delete the userteam enetities in the database if they are already there
            foreach (var item in userteam)
            {
                var uu = _db.UserTeam.Where(gg => gg.Id == item.Id).FirstOrDefault();
                if (uu != null)
                {
                    _db.UserTeam.Remove(item);
                    _db.SaveChanges();
                }
            }

            success = test.DeleteTeam(miteamwithID);
            success = usertest.DeleteUser(user1withID);
        }
 public Challenge(Team team1, Team team2, int gameMode)
 {
     Team1      = team1;
     Team2      = team2;
     GameModeId = gameMode;
 }