public void Delete_ShouldNotEqual()
{
var user = new UserDetailModel
{
FirstName = "John",
LastName = "Doe"
};
var team = new TeamDetailModel
{
Id = Guid.NewGuid(),
Name = "A team"
};
var model = new MembershipModel
{
Id = Guid.NewGuid(),
Position = Position.Leader,
Team = team,
User = user
};
var createdModelId = fixture.Repository.Create(model).Id;
fixture.Repository.Delete(createdModelId);
void Act() => fixture.Repository.GetById(createdModelId);
Assert.Throws <InvalidOperationException>((Action)Act);
}
// GET: Profile/ShowTeam
public ActionResult ShowTeam()
{
if (string.IsNullOrEmpty(Request.QueryString["teamId"]))
{
return(Redirect("~/Profile/Index"));
}
int teamId;
if (!int.TryParse(Request.QueryString["teamId"], out teamId))
{
return(Redirect("~/Profile/Index"));
}
TeamHandle handle = UserManager.Default.QueryTeamById(teamId);
if (handle == null)
{
return(Redirect("~/Error/TeamNotFound"));
}
TeamDetailModel model = TeamDetailModel.FromTeamHandle(handle);
return(View(model));
}
public void Delete_ShouldNotEqual()
{
var user = new UserDetailModel
{
FirstName = "Johny",
Id = Guid.NewGuid(),
LastName = "Depp"
};
var team = new TeamDetailModel
{
Id = Guid.NewGuid(),
Name = "Pirates of the Caribean"
};
var model = new ThreadDetailModel
{
Id = Guid.NewGuid(),
Team = team,
Title = "Test title"
};
var createdModelId = fixture.Repository.Create(model).Id;
fixture.Repository.Delete(createdModelId);
void Act() => fixture.Repository.GetById(createdModelId);
Assert.Throws <InvalidOperationException>((Action)Act);
}
public void Create_WithNonExistingItem_DoesNotThrow()
{
var user = new UserDetailModel
{
FirstName = "John",
LastName = "Doe"
};
var team = new TeamDetailModel
{
Id = Guid.NewGuid(),
Name = "A team"
};
var model = new MembershipModel
{
Id = Guid.NewGuid(),
Position = Position.Leader,
Team = team,
User = user
};
var returnedModel = fixture.Repository.Create(model);
Assert.NotNull(returnedModel);
fixture.Repository.Delete(returnedModel.Id);
}
public IActionResult Details(int id)
{
var fans = _db.Profile.Where(p => p.TeamId == id).ToList();
var teams = _teamService.GetById(id);
var manager = _managerService.GetByTeamId(id);
var stadium = _stadiumService.GetByTeamId(id);
// var players = _playerService.GetAll()
// .Where(p => p.TeamId == id).ToList();
var managerCountry = (from m in _db.Managers
.Where(p => p.TeamId == id)
join c in _db.Countries on m.CountryId equals c.Id
select new { c.Id, c.FlagUrl }).FirstOrDefault();
var players = (from p in _db.Players
.Where(p => p.TeamId == id)
join c in _db.Countries on p.CountryId equals c.Id
select new { p.Id, p.PlayerName, p.PlayerImageUrl, p.DoB, c.FlagUrl });
var teamdet = new TeamDetailModel();
teamdet.Teams = teams;
teamdet.Managers = manager;
teamdet.ManagerCountryUrl = managerCountry.FlagUrl;
teamdet.CountryId = managerCountry.Id;
teamdet.Stadiums = stadium;
teamdet.Fans = fans.Count(p => p.TeamId == teams.Id);
//teamdet.Players = players;
//teamdet.Players = players;
//teamdet.Position = playerPosition.Position;
return(View(teamdet));
}
public void Create_WithNonExistingItem_DoesNotThrow()
{
var user = new UserDetailModel
{
FirstName = "Johny",
Id = Guid.NewGuid(),
LastName = "Depp"
};
var team = new TeamDetailModel
{
Id = Guid.NewGuid(),
Name = "Pirates of the Caribean"
};
var model = new ThreadDetailModel
{
Id = Guid.NewGuid(),
Team = team,
Title = "Test title"
};
var returnedModel = fixture.Repository.Create(model);
Assert.NotNull(returnedModel);
fixture.Repository.Delete(returnedModel.Id);
}
public void TeamsNotEquals()
{
var User = new UserListModel()
{
Id = 4,
Name = "Anton"
};
var Team = new TeamDetailModel()
{
Id = 2,
Leader = User.Id,
Members = new Collection <UserListModel>(),
Name = "Team1"
};
Team.Members.Add(User);
var TheSameUser = new UserListModel()
{
Id = 4,
Name = "Anton"
};
var NotTheSameTeam = new TeamDetailModel()
{
Id = 2,
Leader = TheSameUser.Id,
Members = new Collection <UserListModel>(),
Name = "Team12"
};
Assert.False(Team.Equals(NotTheSameTeam));
}
public void GetAll_ShouldNotReturnNull()
{
var user = new UserDetailModel
{
FirstName = "Johny",
Id = Guid.NewGuid(),
LastName = "Depp"
};
var team = new TeamDetailModel
{
Id = Guid.NewGuid(),
Name = "Pirates of the Caribean"
};
var model = new ThreadDetailModel
{
Id = Guid.NewGuid(),
Team = team,
Title = "Test title"
};
var createdModel = fixture.Repository.Create(model);
var returnedUsersAll = fixture.Repository.GetAll();
Assert.NotNull(returnedUsersAll);
fixture.Repository.Delete(createdModel.Id);
}
public void CreateTeam_WithValidData_ReturnsCreatedTeam()
{
//Arrange
var sut = CreateSUT();
var model = new TeamDetailModel
{
Name = "IFJ projects",
Description = "This team is dedicated for users, " +
"who are working on IFJ projects."
};
TeamDetailModel createdModel = null;
try
{
//Act
createdModel = sut.Create(model);
//Assert
Assert.NotNull(createdModel);
}
finally
{
//Teardown
if (createdModel != null)
{
sut.DeleteTeam(createdModel.Id);
}
}
}
public void UserNotEqualsTeam()
{
var User = new UserListModel()
{
Id = 4,
Name = "Anton"
};
var Team = new TeamDetailModel()
{
Id = 2,
Leader = User.Id,
Members = new Collection <UserListModel>(),
Name = "Team1"
};
var UserListModel = new UserListModel()
{
Id = User.Id,
Name = User.Name
};
var TeamListModel = new TeamListModel()
{
Id = Team.Id,
Name = Team.Name
};
Team.Members.Add(User);
Assert.False(User.Equals(Team));
Assert.False(Team.Equals(User));
}
public void GetAllTeams_WithNeededData_ReturnsCollectionOfTeams()
{
//Arrange
var sut = CreateSUT();
var modelTeam1 = new TeamDetailModel
{
Name = "ICS project 2019",
Description = "This team is dedicated for users, " +
"who are working on ICS projects."
};
var modelTeam2 = new TeamDetailModel
{
Name = "IFJ project 2019",
Description = "This team is dedicated for users, " +
"who are working on IFJ projects."
};
sut.Create(modelTeam1);
sut.Create(modelTeam2);
//Act
var allTeamsModel = sut.GetAllTeams();
//Assert
Assert.Equal(2, allTeamsModel.ToList().Count);
}
public void FindTeamByName_ExistingItem_ReturnsItsModel()
{
//Arrange
var sut = CreateSUT();
var model = new TeamDetailModel
{
Name = "ICS project 2019",
Description = "This team is dedicated for users, " +
"who are working on ICS projects."
};
var createdModel = sut.Create(model);
try
{
//Act
var foundModel = sut.GetByName(createdModel.Name);
//Assert
Assert.NotNull(foundModel);
}
finally
{
//Teardown
sut.DeleteTeam(createdModel.Id);
}
}
public void ModelToEntity_ShouldBeEqual()
{
var user = new UserDetailModel
{
FirstName = "John",
LastName = "Doe"
};
var team = new TeamDetailModel
{
Id = Guid.NewGuid(),
Name = "A team"
};
var model = new MembershipModel
{
Id = Guid.NewGuid(),
Position = Position.Leader,
Team = team,
User = user
};
var returned = MembershipMapper.ModelToEntity(model);
Assert.Equal(model.Id, returned.Id);
Assert.Equal(model.Position, returned.Position);
Assert.Equal(model.User.FirstName, returned.User.FirstName);
Assert.Equal(model.User.LastName, returned.User.LastName);
Assert.Equal(model.Team.Name, returned.Team.Name);
Assert.IsType <Membership>(returned);
}
public ActionResult UserTeams()
{
string username = Request.QueryString["username"];
if (string.IsNullOrEmpty(username))
{
return(QueryResult(1, "Username is required."));
}
if (!UserManager.Default.IsUserExist(username))
{
return(QueryResult(2, "Username is not exist."));
}
UserHandle user = new UserHandle(username);
List <TeamDetailModel> teams = new List <TeamDetailModel>();
using (UserDataProvider userData = UserDataProvider.Create(user, true))
{
foreach (TeamHandle team in userData.GetTeams())
{
teams.Add(TeamDetailModel.FromTeamHandle(team));
}
}
return(QueryResult(teams));
}
public void DeleteTeam()
{
var sut = CreateSUT();
var admin = new UserDetailModel()
{
Id = Guid.NewGuid(),
LastName = "Doe",
FirstName = "John",
Password = "******",
Email = "*****@*****.**"
};
var team = new TeamDetailModel()
{
Id = Guid.NewGuid(),
Admin = admin,
Name = "Team1",
Description = "Team1 description"
};
var createdTeam = sut.Create(team);
sut.Delete(createdTeam.Id);
Assert.Throws <NullReferenceException>(() => sut.GetById(createdTeam.Id));
}
public void Update_TeamModel_Test()
{
var teamOnemodel = new TeamDetailModel
{
Name = "Stary tym"
};
var teamTwoModel = new TeamDetailModel
{
Name = "Muj tym",
};
var returnedModel = _teamRepository.Create(teamOnemodel);
returnedModel = _teamRepository.Create(teamTwoModel);
var newModel = new TeamDetailModel
{
Id = returnedModel.Id,
Name = "Novy tym",
};
_teamRepository.Create(newModel);
var updatedModel = _teamRepository.GetById(returnedModel.Id);
Assert.Equal("Novy tym", updatedModel.Name);
//Teardown
_teamRepository.Delete(updatedModel.Id);
}
public TeamEntity DetailModelToEntity(TeamDetailModel teamDetailModel)
{
if (teamDetailModel == null)
{
return(null);
}
var teamEntity = new TeamEntity
{
Id = teamDetailModel.Id,
Leader = teamDetailModel.Leader,
Name = teamDetailModel.Name,
Members = new Collection <TeamUserEntity>()
};
if (teamDetailModel.Members == null)
{
teamDetailModel.Members = new Collection <UserListModel>();
}
else
{
foreach (var member in teamDetailModel.Members)
{
var user = new TeamUserEntity
{
UserName = member.Name,
UserId = member.Id
};
teamEntity.Members.Add(user);
}
}
return(teamEntity);
}
public async Task <IActionResult> PutTeam(Guid id, TeamDetailModel team)
{
if (id != team.Id)
{
return(BadRequest());
}
try
{
facade.Save(team);
}
catch (DbUpdateConcurrencyException)
{
if (!TeamExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void GetById_ShouldBeEqual()
{
var user = new UserDetailModel
{
FirstName = "John",
LastName = "Doe"
};
var team = new TeamDetailModel
{
Id = Guid.NewGuid(),
Name = "A team"
};
var model = new MembershipModel
{
Id = Guid.NewGuid(),
Position = Position.Leader,
Team = team,
User = user
};
var createdModel = fixture.Repository.Create(model);
Assert.Equal(createdModel.Id, fixture.Repository.GetById(createdModel.Id).Id);
fixture.Repository.Delete(createdModel.Id);
}
public void GetById_ShouldBeEqual()
{
var user = new UserDetailModel
{
FirstName = "Alfred",
Id = Guid.NewGuid(),
LastName = "Hitchcock"
};
var team = new TeamDetailModel
{
Id = Guid.NewGuid(),
Name = "Musicians"
};
var comment = new CommentDetailModel
{
Author = user,
Id = Guid.NewGuid(),
Timestamp = new DateTime(2019, 10, 22)
};
var createdModel = fixture.Repository.Create(new UserLogModel
{
Id = Guid.NewGuid(),
Action = Operation.CommentCreate,
});
Assert.Equal(createdModel.Id, fixture.Repository.GetById(createdModel.Id).Id);
fixture.Repository.Delete(createdModel.Id);
}
public void GetAll_ShouldNotReturnNull()
{
var user = new UserDetailModel
{
FirstName = "John",
LastName = "Doe"
};
var team = new TeamDetailModel
{
Id = Guid.NewGuid(),
Name = "A team"
};
var model = new MembershipModel
{
Id = Guid.NewGuid(),
Position = Position.Leader,
Team = team,
User = user
};
var createdModel = fixture.Repository.Create(model);
var returnedUsersAll = fixture.Repository.GetAll();
Assert.NotNull(returnedUsersAll);
fixture.Repository.Delete(createdModel.Id);
}
public TeamDetailModel RemovePost(TeamDetailModel teamModel, PostDetailModel postModel)
{
using (var dbContext = _dbContextFactory.CreateTeamChatDbContext())
{
var teamEntity = dbContext.Teams
.Include(p => p.Posts)?
.ThenInclude(c => c.Comments)
.ThenInclude(a => a.Author)
.Include(m => m.Members)
.ThenInclude(u => u.User)
.First(t => t.Id == teamModel.Id);
var postEntity = dbContext.Posts
.Include(a => a.Author)
.Include(c => c.Comments)
.ThenInclude(a => a.Author)
.First(p => p.Id == postModel.Id);
teamEntity.Posts.Remove(postEntity);
dbContext.SaveChanges();
return(TeamMapper.MapToDetailModel(teamEntity));
}
}
public TeamDetailModel EntityToDetailModel(TeamEntity teamEntity)
{
if (teamEntity == null)
{
return(null);
}
var teamModel = new TeamDetailModel
{
Id = teamEntity.Id,
Leader = teamEntity.Leader,
Name = teamEntity.Name,
Members = new Collection <UserListModel>()
};
if (teamEntity.Members == null)
{
teamEntity.Members = new Collection <TeamUserEntity>();
}
else
{
foreach (var member in teamEntity.Members)
{
teamModel.Members.Add(new UserListModel()
{
Id = member.UserId,
Name = member.UserName
});
}
}
return(teamModel);
}
public void CreateComment()
{
var sut = CreateSUT();
var posts = CreatePost();
var users = CreateUser();
var postAuthor = new UserDetailModel()
{
Id = Guid.NewGuid(),
FirstName = "Adrian",
LastName = "New",
Email = "*****@*****.**",
Password = "******"
};
var adminOfTeam = new UserDetailModel()
{
Id = Guid.NewGuid(),
FirstName = "Harry",
LastName = "Callum",
Email = "*****@*****.**",
Password = "******"
};
var teamForPost = new TeamDetailModel()
{
Id = Guid.NewGuid(),
Admin = adminOfTeam,
Description = "Harry Callum Team",
Name = "United"
};
var postModel = new PostModel()
{
Id = Guid.NewGuid(),
Author = postAuthor,
Created = DateTime.Now.ToString("MM/dd/yyyy HH:mm"),
Team = teamForPost,
Text = "Post in harry callum team",
Title = "Main Title"
};
var commentAuthor = new UserDetailModel()
{
Id = Guid.NewGuid(),
FirstName = "Oliver",
LastName = "Jake",
Email = "*****@*****.**",
Password = "******"
};
var model = new CommentModel()
{
Id = Guid.NewGuid(),
Author = commentAuthor,
Created = DateTime.Now.ToString("MM/dd/yyyy HH:mm"),
Post = postModel,
Text = "Comment on post in team"
};
posts.Create(postModel);
users.Create(commentAuthor);
sut.Create(model);
Assert.NotNull(model);
}
public ActionResult Create()
{
var model = new TeamDetailModel {
};
PopulateViewData();
return(View(model));
}
public TeamEditViewModel(IMessenger messenger, ViewModelLocator locator)
{
_locator = locator;
_messenger = messenger;
SaveCommand = new RelayCommand(Save);
DeleteCommand = new RelayCommand(Delete);
Team = new TeamDetailModel();
}
public void Delete(TeamDetailModel detailModel)
{
using (var dbContext = _dbContextFactory.CreateTeamChatDbContext())
{
dbContext.Remove(dbContext.Find(typeof(Team), detailModel.Id));
dbContext.SaveChanges();
}
}
public void Update(TeamDetailModel model)
{
using (var dbContext = dbContextFactory.CreateDbContext())
{
var entity = TeamMapper.DetailModelToEntity(model);
dbContext.Teams.Update(entity);
dbContext.SaveChanges();
}
}
private TeamModel ConvertTeamDetailModel(TeamDetailModel model)
{
return(new TeamModel
{
Name = model.Name,
Description = model.Description,
Members = model.Members,
});
}
public Team MapTeamToEntity(TeamDetailModel team)
{
return(new Team
{
Id = team.Id,
Name = team.Name,
Description = team.Description
});
}
public ActionResult Edit(TeamDetailModel model)
{
if (ModelState.IsValid)
{
TeamRepository.Update(ConvertTeamDetailModel(model));
ViewBag.UpdateSuccess = true;
}
PopulateViewData();
return View(model);
}
public ActionResult Create(TeamDetailModel model)
{
while (!String.IsNullOrEmpty(model.Name) && model.Name.Last() == ' ')
{
model.Name = model.Name.Substring(0, model.Name.Length - 1);
}
if (ModelState.IsValid)
{
if (TeamRepository.Create(ConvertTeamDetailModel(model)))
{
TempData["CreateSuccess"] = true;
return RedirectToAction("Index");
}
else
{
ModelState.AddModelError("", Resources.Team_Create_Failure);
}
}
PopulateViewData();
return View(model);
}
public ActionResult Delete(TeamDetailModel model)
{
if (model != null && !String.IsNullOrEmpty(model.Name))
{
TeamRepository.Delete(model.Name);
TempData["DeleteSuccess"] = true;
return RedirectToAction("Index");
}
return RedirectToAction("Index");
}
private TeamModel ConvertTeamDetailModel(TeamDetailModel model)
{
return new TeamModel
{
Name = model.Name,
Description = model.Description,
Members = model.Members,
};
}
public ActionResult Create()
{
var model = new TeamDetailModel { };
PopulateViewData();
return View(model);
}
