/// <summary>
/// Initializes a new instance of the <see cref="SendToChannelConversationService"/> class.
/// </summary>
/// <param name="bfsClient">The BFS client service.</param>
/// <param name="teamRepository">The team repository service.</param>
public SendToChannelConversationService(
BFSClient bfsClient,
TeamRepository teamRepository)
{
this.bfsClient = bfsClient;
this.teamRepository = teamRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="GroupingNotificationsByTeamService"/> class.
/// </summary>
/// <param name="eventRepository">The event repository service.</param>
/// <param name="teamRepository">The team repository service.</param>
public GroupingNotificationsByTeamService(
EventRepository eventRepository,
TeamRepository teamRepository)
{
this.eventRepository = eventRepository;
this.teamRepository = teamRepository;
}
public CachedTeamRepository()
{
_teamRepository = new TeamRepository();
_teamsInClubResults = new List <CachedTeamsInClubResult>();
_seasonsForTeamResults = new List <CachedSeasonsForTeamResult>();
_teams = new Dictionary <DateTime, Team>();
}
public void SaveNewGameAndExistingTeamsTest()
{
// setup
Game saved = null;
string homeTeam = "TestTeam1", awayTeam = "TestTeam2";
long homeId = -1, awayId = -1, gameId = -1;
using (var repository = new TeamRepository())
{
homeId = repository.Add(new Team() { Name = homeTeam });
awayId = repository.Add(new Team() { Name = awayTeam });
}
Game game = new Game()
{
Start = new DateTime(2014, 1, 1),
HomeTeamId = homeId,
AwayTeamId = awayId,
TweetsRetrieved = RetrievalStatus.NONE
};
// execute
using (var repository = new GameRepository())
{
gameId = repository.Save(game).Id;
saved = (from g in repository.DataSet.Include("HomeTeam").Include("AwayTeam")
where g.Id == gameId
select g).FirstOrDefault();
}
// validate
Assert.IsNotNull(saved);
Assert.IsNotNull(saved.HomeTeam);
Assert.IsNotNull(saved.AwayTeam);
Assert.AreEqual(homeTeam, saved.HomeTeam.Name);
Assert.AreEqual(awayTeam, saved.AwayTeam.Name);
}
public CreateOutput <TeamDto, long> Create(CreateTeamInput input)
{
Team newTeamEntity = input.Entity.MapTo <Team>();
if (!TeamPolicy.CanCreateEntity(newTeamEntity))
{
throw new CityQuestPolicyException(CityQuestConsts.CQPolicyExceptionCreateDenied, "\"Team\"");
}
newTeamEntity.IsActive = true;
newTeamEntity.IsDefault = false;
TeamRepository.Includes.Add(r => r.LastModifierUser);
TeamRepository.Includes.Add(r => r.CreatorUser);
TeamRepository.Includes.Add(r => r.PlayerCareers);
TeamDto newTeamDto = (TeamRepository.Insert(newTeamEntity)).MapTo <TeamDto>();
TeamRepository.Includes.Clear();
return(new CreateOutput <TeamDto, long>()
{
CreatedEntity = newTeamDto
});
}
// PUT api/<controller>/5
//public Team Put(int id, [FromBody]string formdata)
//{
// var TeamRepo = new TeamRepository();
// if (formdata != string.Empty)
// {
// var formValues = formdata.Split('&').Select(s => s.Split('=')).ToDictionary(key => key[0].Trim(), value => value[1].Trim());
// var team = TeamRepo.FindBy(id);
// team.Name = formValues["TeamName"].Replace("+", " ");
// team.GroupNumber = formValues["GroupNumber"];
// team.TeamLeaderId = Convert.ToInt32(formValues["TeamLeaderId"]);
// TeamRepo.Update(team);
// TeamRepo.Save();
// return team;
// }
// return new Team();
//}
// DELETE api/<controller>/5
public void Delete(int id)
{
var repos = new TeamRepository();
repos.Delete(id);
repos.Save();
}
public async Task GetTeamsQuery_Can_Return_Teams()
{
var dbContext = GetDbContext("GetTeamsQuery_Can_Return_Teams");
using (dbContext)
{
var fakeRepo = new TeamRepository(dbContext);
var fakeLogger = new Mock <ILogger <GetTeamsQueryHandler> >();
var handler = new GetTeamsQueryHandler(fakeRepo, GetMapper(), fakeLogger.Object);
var TeamToAdd = new Team
{
Name = "TeamName",
Longitude = 8.11,
Latitude = 9.43,
};
await fakeRepo.AddAsync(TeamToAdd);
var result = await handler.Handle(new GetTeamsQuery(), default);
Assert.False(result.Notifications.HasErrors());
Assert.Equal(1, result.Teams.Count);
Assert.Equal(TeamToAdd.Name, result.Teams[0].Name);
Assert.Equal(TeamToAdd.Longitude, result.Teams[0].Longitude);
Assert.Equal(TeamToAdd.Longitude, result.Teams[0].Longitude);
}
}
private Team[] GetTeamsInLeague(int leagueId)
{
using (ITeamRepository repository = new TeamRepository(DatabaseSourceDefinitor.ConnectionString))
{
return(repository.GetTeamsByLeague(leagueId).ToArray());
}
}
public Guid GetOwner(OptionSetValue caseOriginCode)
{
TeamRepository teamRepository = new TeamRepository(_service);
Entity team = teamRepository.GetTeams(caseOriginCode.Value).Entities.FirstOrDefault();
if (team == null)
{
return(Guid.Empty);
}
EntityReference teamEntityId = team.GetAttributeValue <EntityReference>("new_team");
UsersRepository usersRepository = new UsersRepository(_service);
var users = usersRepository.GetUsers(teamEntityId.Id);
CaseRepository caseRepository = new CaseRepository(_service);
Dictionary <Guid, int> keyValuePairs = new Dictionary <Guid, int>();
for (int i = 0; i < users.Count; i++)
{
Guid id = users[i].Id;
int count = caseRepository.GetCasesCountByUsers(id.ToString());
keyValuePairs.Add(id, count);
}
int minValue = keyValuePairs.Values.Min();
var newOwner = keyValuePairs.Where(q => q.Value == minValue).FirstOrDefault();
return(newOwner.Key);
}
private Team[] GetTeamsOfCountry(int countryId)
{
using (ITeamRepository repository = new TeamRepository(DatabaseSourceDefinitor.ConnectionString))
{
return(repository.GetTeamsByCountry(countryId).ToArray());
}
}
// GET: Team/Edit/5
public ActionResult Edit(int id)
{
TeamRepository teamRepository = TeamRepository.getInstance();
var search = teamRepository.search(id);
return(View(search));
}
public TeamsController()
{
_teamRepository = new TeamRepository(AppUser);
_teamService = new TeamService(AppUser);
_teamRepository.OnChange += SyncManager.OnChange;
_teamService.OnChange += SyncManager.OnChange;
}
public UpdateOutput <TeamDto, long> Update(UpdateTeamInput input)
{
TeamRepository.Includes.Add(r => r.LastModifierUser);
TeamRepository.Includes.Add(r => r.CreatorUser);
TeamRepository.Includes.Add(r => r.PlayerCareers);
Team currentTeamEntity = TeamRepository.Get(input.Entity.Id);
if (currentTeamEntity == null)
{
throw new CityQuestItemNotFoundException(CityQuestConsts.CityQuestItemNotFoundExceptionMessageBody, "\"Team\"");
}
if (!TeamPolicy.CanUpdateEntity(currentTeamEntity))
{
throw new CityQuestPolicyException(CityQuestConsts.CQPolicyExceptionUpdateDenied, "\"Team\"");
}
TeamRepository.Detach(currentTeamEntity);
Team newTeamEntity = input.Entity.MapTo <Team>();
newTeamEntity.IsDefault = currentTeamEntity.IsDefault;
TeamRepository.Update(newTeamEntity);
TeamDto newTeamDto = (TeamRepository.Get(newTeamEntity.Id)).MapTo <TeamDto>();
TeamRepository.Includes.Clear();
return(new UpdateOutput <TeamDto, long>()
{
UpdatedEntity = newTeamDto
});
}
public IActionResult ChangePerson(Guid personId)
{
Person person = Personrepository.IncludeGet(p => p.Team).FirstOrDefault(p => p.Id == personId);
ViewBag.Teams = TeamRepository.Get().ToList();
return(View(person));
}
public UserBusiness(IUnitOfWork _unitOfWork)
{
unitOfWork = _unitOfWork;
playerRepository = new PlayerRepository(unitOfWork);
teamRepository = new TeamRepository(unitOfWork);
userRepository = new UserRepository(unitOfWork);
}
/// <summary>
/// Clear out everything except the admin user
/// </summary>
private void DoFullReset()
{
foreach (var repository in Repository.GetAllRepositories())
{
Repository.Delete(repository.Id);
}
foreach (var team in TeamRepository.GetAllTeams())
{
TeamRepository.Delete(team.Id);
}
foreach (var user in Users.GetAllUsers())
{
if (!user.Username.Equals("Admin", StringComparison.OrdinalIgnoreCase))
{
Users.DeleteUser(user.Id);
}
}
foreach (var role in RoleProvider.GetAllRoles())
{
if (role != Definitions.Roles.Administrator)
{
RoleProvider.DeleteRole(role, true);
}
}
}
public ActionResult Team(int Id)
{
TeamRepository db = new TeamRepository();
var team = db.GetAllTeams().Where(k => k.TeamId == Id).FirstOrDefault();
return(View(team));
}
private Participant GetEntryById(int id)
{
TeamRepository repository = new TeamRepository();
Participant team = repository.GetEntryById(id);
return(team);
}
public IEnumerable<Match> GetMatchesOfTeam(int id)
{
TeamRepository tmp = new TeamRepository();
var team = tmp.GetById(id);
var qres = _repository.GetAllMatchesOfTeam(team);
return qres.Select(o => new APIMatch(o)).ToList();
}
public static XPathNodeIterator GetTeam(int teamId)
{
var teamRepository = new TeamRepository();
var team = teamRepository.GetById(teamId);
return TeamToXml(team);
}
/// <summary>
/// Initializes a new instance of the <see cref="PersonAddedInChannelHandler"/> class.
/// </summary>
/// <param name="teamRepository">The team repository.</param>
/// <param name="welcomeTeamAndMembersService">The welcome team and members service.</param>
public PersonAddedInChannelHandler(
TeamRepository teamRepository,
WelcomeTeamMembersService welcomeTeamAndMembersService)
{
this.teamRepository = teamRepository;
this.welcomeTeamAndMembersService = welcomeTeamAndMembersService;
}
public TeamsController()
{
_teamRepository = new TeamRepository(AppUser);
_teamService = new TeamService(AppUser);
_teamRepository.OnChange += SyncManager.OnChange;
_teamService.OnChange += SyncManager.OnChange;
}
public IHttpActionResult TeamProfileTOGroupProfileService()
{
TeamRepository Tr = new TeamRepository();
GroupProfileRepository GpR = new GroupProfileRepository();
TeamMemberProfileRepository TMPR = new TeamMemberProfileRepository();
List <Domain.Socioboard.Domain.Team> lstTeam = Tr.GetAllActiveTeam();
foreach (var item in lstTeam)
{
List <Domain.Socioboard.Domain.TeamMemberProfile> lstTeamMemberprofiles = TMPR.getAllTeamMemberProfilesOfTeam(item.Id);
foreach (var memProfile in lstTeamMemberprofiles)
{
Domain.Socioboard.Domain.GroupProfile grpProfile = new Domain.Socioboard.Domain.GroupProfile();
grpProfile.Id = Guid.NewGuid();
grpProfile.EntryDate = memProfile.StatusUpdateDate;
grpProfile.GroupId = item.GroupId;
grpProfile.GroupOwnerId = item.UserId;
grpProfile.ProfileId = memProfile.ProfileId;
grpProfile.ProfileName = memProfile.ProfileName;
grpProfile.ProfileType = memProfile.ProfileType;
grpProfile.ProfilePic = memProfile.ProfilePicUrl;
if (!GpR.checkProfileExistsingroup(grpProfile.GroupId, grpProfile.ProfileId))
{
GpR.AddGroupProfile(grpProfile);
}
}
}
return(Ok());
}
public ChangeCaptainOutput ChangeCaptain(ChangeCaptainInput input)
{
TeamRepository.Includes.Add(r => r.PlayerCareers);
Team teamEntity = TeamRepository.Get(input.TeamId);
if (teamEntity == null)
{
throw new CityQuestItemNotFoundException(CityQuestConsts.CityQuestItemNotFoundExceptionMessageBody, "\"Team\"");
}
if (!TeamPolicy.CanChangeCaptainForEntity(teamEntity))
{
throw new CityQuestPolicyException(CityQuestConsts.CQPolicyExceptionUpdateDenied, "\"Team\"");
}
PlayerCareer newCap = teamEntity.PlayerCareers.SingleOrDefault(r => r.Id == input.NewCaptainCareerId);
if (newCap != null)
{
var oldCap = teamEntity.Captain;
if (oldCap.Id != newCap.Id)
{
newCap.IsCaptain = true;
PlayerCareerRepository.Update(newCap);
oldCap.IsCaptain = false;
PlayerCareerRepository.Update(oldCap);
}
}
return(new ChangeCaptainOutput());
}
private Models.LeaderboardViewModel GetLeaderboardViewModel()
{
TeamRepository teamRepo = new TeamRepository();
List <TeamScore> teamScores = new List <TeamScore>();
List <Team> teams = teamRepo.GetAll().Where(i => !i.IsAdmin).ToList();
foreach (var team in teams)
{
List <Scorecard> scores = getTeamScore(team.ID).scores.ToList();
int summedScore = GlobalRoutines.SumScores(scores);
int thru = scores.Where(s => s.Value > 0).Count();
teamScores.Add(new TeamScore
{
TeamName = team.Name,
Score = summedScore,
ScoreDisplay = summedScore == 0 ? "Even" : summedScore.ToString(),
Thru = thru > 0 ? thru.ToString() : "-"
});
}
Models.LeaderboardViewModel vm = new Models.LeaderboardViewModel()
{
TeamScores = teamScores.OrderBy(s => s.Score)
};
return(vm);
}
// GET: Dashboard
public ActionResult Index()
{
var DbUsers = db.UserDetailsModel.ToList();
DashboardViewModels dashboardVM = new DashboardViewModels();
UserDetailsRepository UDR = new UserDetailsRepository();
dashboardVM.UserList = UDR.GetUsers();
TeamRepository TR = new TeamRepository();
dashboardVM.TeamList = TR.GetTeams();
List <IdentityRole> roles = db.Roles.ToList();
dashboardVM.RoleList = roles;
VacationRepository vac = new VacationRepository();
BankHolidayRepository bank = new BankHolidayRepository();
CalendarViewModel calendar = new CalendarViewModel();
calendar.BankHolidayList = bank.GetBankHolidays();
calendar.VacationList = vac.GetVacations();
dashboardVM.Calendar = calendar;
return(View(dashboardVM));
}
public IActionResult ChangePersonPost(Person person, Guid personId)
{
Team team = new Team();
bool teamChecknull = true;
if (person.TeamId == null)
{
teamChecknull = false;
}
else
{
team = TeamRepository.FindById((Guid)person.TeamId);
}
Person Updateperson = Personrepository.IncludeGet(p => p.Team).FirstOrDefault(p => p.Id == personId);
Updateperson.Name = person.Name;
Updateperson.LastName = person.LastName;
Updateperson.Days = person.Days;
if (!teamChecknull)
{
Updateperson.Team = null;
}
else
{
Updateperson.Team = team;
}
if (Updateperson.Days < 0 || Updateperson.Days > 20)
{
return(Redirect("~/Home/Workers/Home/Workers"));
}
Personrepository.Update(Updateperson);
return(Redirect("~/Home/Workers/Home/Workers"));
}
public FixtureBusiness(IUnitOfWork _unitOfWork)
{
unitOfWork = _unitOfWork;
playerRepository = new PlayerRepository(unitOfWork);
teamRepository = new TeamRepository(unitOfWork);
fixtureRepository = new FixtureRepository(unitOfWork);
}
private void saveButton_Click(object sender, EventArgs e)
{
if (validate())
{
if (handle != null)
{
handle.Name = nameInput.Text;
var repo = new TeamRepository();
repo.SaveOrUpdate(handle);
DialogResult result = MetroMessageBox.Show(this, "Team updated!", "Success!", MessageBoxButtons.OK,
MessageBoxIcon.Information);
if (result == DialogResult.OK)
{
}
}
else
{
Team newTeam = new Team();
newTeam.Players = new List<Player>();
newTeam.Name = nameInput.Text;
newTeam.Discipline = discipline;
var repo = new TeamRepository();
repo.SaveOrUpdate(newTeam);
DialogResult result = MetroMessageBox.Show(this, "Team created!", "Success!", MessageBoxButtons.OK,
MessageBoxIcon.Information);
if (result == DialogResult.OK)
{
}
}
}
}
public IHttpActionResult Get(int id)
{
try
{
Team team = null;
var teamRepository = new TeamRepository();
if (id > 0)
{
var teams = teamRepository.Retrieve();
team = teams.FirstOrDefault(t => t.ID == id);
if (team == null)
{
return NotFound();
}
}
return Ok(team);
}
catch (Exception ex)
{
return InternalServerError(ex);
}
}
public RetrieveAllOutput <TeamDto, long> RetrieveAll(RetrieveAllTeamsInput input)
{
if (input.IsActive ?? true)
{
UowManager.Current.EnableFilter(Filters.IPassivableFilter);
}
TeamRepository.Includes.Add(r => r.LastModifierUser);
TeamRepository.Includes.Add(r => r.CreatorUser);
TeamRepository.Includes.Add(r => r.PlayerCareers);
IList <Team> teamEntities = TeamPolicy.CanRetrieveManyEntities(
TeamRepository.GetAll()
.WhereIf(!input.TeamIds.IsNullOrEmpty(), r => input.TeamIds.Contains(r.Id))
.WhereIf(input.DivisionId != null, r => r.DivisionId == input.DivisionId)
.WhereIf(!String.IsNullOrEmpty(input.Name), r => r.Name.ToLower().Contains(input.Name.ToLower())))
.ToList();
IList <TeamDto> result = teamEntities.MapIList <Team, TeamDto>();
TeamRepository.Includes.Clear();
return(new RetrieveAllOutput <TeamDto, long>()
{
RetrievedEntities = result
});
}
public RetrieveAllPagedResultOutput <TeamDto, long> RetrieveAllPagedResult(RetrieveAllTeamsPagedResultInput input)
{
if (input.IsActive ?? true)
{
UowManager.Current.EnableFilter(Filters.IPassivableFilter);
}
TeamRepository.Includes.Add(r => r.LastModifierUser);
TeamRepository.Includes.Add(r => r.CreatorUser);
TeamRepository.Includes.Add(r => r.PlayerCareers);
IQueryable <Team> teamsQuery = TeamPolicy.CanRetrieveManyEntities(
TeamRepository.GetAll()
.WhereIf(!input.TeamIds.IsNullOrEmpty(), r => input.TeamIds.Contains(r.Id))
.WhereIf(input.DivisionId != null, r => r.DivisionId == input.DivisionId)
.WhereIf(!String.IsNullOrEmpty(input.Name), r => r.Name.ToLower().Contains(input.Name.ToLower())));
int totalCount = teamsQuery.Count();
IReadOnlyList <TeamDto> teamDtos = teamsQuery
.OrderByDescending(r => r.IsActive).ThenBy(r => r.Name)
.Skip(input.SkipCount).Take(input.MaxResultCount)
.ToList().MapIList <Team, TeamDto>().ToList();
TeamRepository.Includes.Clear();
return(new RetrieveAllPagedResultOutput <TeamDto, long>()
{
Items = teamDtos,
TotalCount = totalCount
});
}
public void AddTeamTest()
{
TeamRepository target = new TeamRepository(); // TODO: Initialize to an appropriate value
Team team = null; // TODO: Initialize to an appropriate value
target.AddTeam(team);
Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
private string LoadTeamTiles()
{
var teamGuid = Request.Params["SiteGUID"].ToString();
string userAlias = Session["UserName"].ToString();
// tile data
JavaScriptSerializer jss = new JavaScriptSerializer();
// Save the tile data into our database
using (MainDBUnitWorkContext context = new MainDBUnitWorkContext())
{
TileRepository repository = new TileRepository(context);
// Get the team id by its team guid value
TeamRepository tRepository = new TeamRepository(context);
TeamAppService teamService = new TeamAppService(tRepository);
TileQueryLogicRepository tileQueryRepository = new TileQueryLogicRepository(context);
ReportRepository reportRepository = new ReportRepository(context);
int teamId = teamService.GetAllTeamSites().First(_ => _.TeamGuid == Guid.Parse(teamGuid)).Id.Value;
TileServices tService = new TileServices(repository, tRepository, reportRepository, null, null, null, tileQueryRepository);
List <TileViewModel> tiles = tService.GetCustomerizeTilesWithCountByTeamId(teamId, userAlias, true, teamGuid).Select(_ => _.ToTileViewModel()).ToList <TileViewModel>();
return(jss.Serialize(tiles));
}
}
protected override bool AuthorizeCore(HttpContextBase httpContext)
{
HttpCookie c = httpContext.Request.Cookies.Get("current_team");
HttpCookie expires = httpContext.Request.Cookies.Get("current_expires");
if (SessionVars.Item.Team == null)
{
if (c != null && expires != null && Convert.ToDateTime(expires.Value) > DateTime.Now && c.Value != "")
{
TeamRepository teamRepo = new TeamRepository();
int TeamID = 0;
int.TryParse(c.Value, out TeamID);
SessionVars.Item.Team = teamRepo.GetByID(TeamID);
teamRepo.Dispose();
return(true);
}
else
{
return(false);
}
}
else
{
return(true);
}
}
/// <summary>
/// /api/team/
/// </summary>
/// <returns></returns>
public IEnumerable<Team> Get()
{
using (var repository = new TeamRepository())
{
return repository.GetAll().ToList();
}
}
// GET: Team
public ActionResult Index()
{
TeamRepository teamRepository = TeamRepository.getInstance();
var team = teamRepository.getTeamForUser(User.Identity.GetUserId());
return(View(team));
}
void LoadMembers(int teamid)
{
var myTeam = new TeamRepository().FindBy(teamid);
ltrHeader.Text = myTeam.TeamName + " Members";
LoadMembers(myTeam.Members);
}
public void GetDivisionTeamsTest()
{
var csbcDbContext = new CSBCDbContext();
var rep = new TeamRepository(csbcDbContext);
var divisions = csbcDbContext.Divisions.Select(s => s);
var teams = rep.GetTeams(divisions.First<Division>().DivisionID);
Assert.IsTrue(teams.Any<Team>());
}
public MatchController()
{
DtoMatcbConverter = new DTOMatchConverter();
var facade = new DALFacade();
matchRepository = facade.GetMatchRepository();
teamRepository = facade.GetTeamRepository();
groupRepository = facade.GetGroupRepository();
tournamentRepository = facade.GetTournamentRepository();
}
public void SetMatchFromBet()
{
var teamRepository = new TeamRepository();
KnockoutMatch.HomeTeamId = HomeTeamId;
KnockoutMatch.AwayTeamId = AwayTeamId;
KnockoutMatch.HomeTeam = teamRepository.Find(HomeTeamId);
KnockoutMatch.AwayTeam = teamRepository.Find(AwayTeamId);
KnockoutMatch.HomeTeamGoals = HomeTeamGoals;
KnockoutMatch.AwayTeamGoals = AwayTeamGoals;
}
public void Can_remove_existing_Team()
{
var Team = new Team() { Id = 1 };
ITeamRepository repository = new TeamRepository();
repository.Delete(Team);
using (ISession session = _sessionFactory.OpenSession())
{
var fromDb = session.Get<Team>(Team.Id);
Assert.IsNull(fromDb);
}
}
public IHttpActionResult Get()
{
try
{
var teamRepository = new TeamRepository();
return Ok(teamRepository.Retrieve().AsQueryable());
}
catch (Exception ex)
{
return InternalServerError(ex);
}
}
public void Can_update_existing_Team()
{
ITeamRepository repository = new TeamRepository();
var Team = new Team() { Id = 1, City = "Atlanta" };
repository.Save(Team);
// use session to try to load the product
using (ISession session = _sessionFactory.OpenSession())
{
var fromDb = session.Get<Team>(Team.Id);
Assert.AreEqual(Team.City, fromDb.City);
}
}
public IHttpActionResult Follow()
{
var uId = Int32.Parse(HttpContext.Current.Request.Form.GetValues("userId").FirstOrDefault());
var tId = Int32.Parse(HttpContext.Current.Request.Form.GetValues("teamId").FirstOrDefault());
var uRepo = new UserRepository();
var tRepo = new TeamRepository();
if (!(uRepo.ContainsId(uId) && tRepo.ContainsId(tId)))
return NotFound();
var u = uRepo.GetById(uId);
var t = tRepo.GetById(tId);
u.FollowedTeams.Add(t);
uRepo.SaveOrUpdate(u);
return Ok();
}
public Game GameFromArray(string[] line)
{
// set up a new game
Game game = new Game();
// set up the teams
using (var repository = new TeamRepository())
{
var teams = (repository.GetAll().Where(t => t.Name == line[iHome])).ToList();
if (teams.Count > 0)
{
game.HomeTeamId = teams[0].Id;
}
else
{
var home = new Team() { Name = line[iHome] };
home.Id = repository.Add(home);
game.HomeTeamId = home.Id;
}
teams = (repository.GetAll().Where(t => t.Name == line[iAway])).ToList();
if (teams.Count > 0)
{
game.AwayTeamId = teams[0].Id;
}
else
{
var away = new Team() { Name = line[iAway] };
away.Id = repository.Add(away);
game.AwayTeamId = away.Id;
}
}
// get the start time
DateTime start = DateTime.Parse(line[iDate]);
TimeSpan time = TimeSpan.Parse(line[iTime]);
game.Start = start + time;
// get the score
string score = line[iScore];
var scores = Regex.Matches(score, @"\d");
game.HomeGoals = Int32.Parse(scores[0].Value);
game.AwayGoals = Int32.Parse(scores[1].Value);
// set the status of the tweet mining
game.TweetsRetrieved = RetrievalStatus.NONE;
return game;
}
public void Can_add_new_Team()
{
var Team = new Team { City = "Pittsburgh" };
ITeamRepository repository = new TeamRepository();
repository.Save(Team);
// use session to try to load the product
using (ISession session = _sessionFactory.OpenSession())
{
var fromDb = session.Get<Team>(Team.Id);
// Test that the product was successfully inserted
Assert.IsNotNull(fromDb);
Assert.AreNotSame(Team, fromDb);
Assert.AreEqual(Team.City, fromDb.City);
}
}
public IHttpActionResult UnFollow()
{
var uId = Int32.Parse(HttpContext.Current.Request.Form.GetValues("userId").FirstOrDefault());
var tId = Int32.Parse(HttpContext.Current.Request.Form.GetValues("teamId").FirstOrDefault());
var uRepo = new UserRepository();
var tRepo = new TeamRepository();
if (!(uRepo.ContainsId(uId) && tRepo.ContainsId(tId)))
return NotFound();
var u = uRepo.GetById(uId);
var t = tRepo.GetById(tId);
if (u.FollowedTeams.Where(x => x.Id == t.Id).Take(1).Count() > 0)
{
u.FollowedTeams.Remove(t);
t.FollowedBy.Remove(u);
}
uRepo.SaveOrUpdate(u);
return Ok();
}
public IHttpActionResult Get(string search)
{
try
{
var teamRepository = new TeamRepository();
var teams = teamRepository.Retrieve();
var updatedTeam = teams.Where(t => t.Team_ID.Contains(search)) as Team;
if (updatedTeam == null)
{
return NotFound();
}
else
{
return Ok(updatedTeam);
}
}
catch (Exception ex)
{
return InternalServerError(ex);
}
}
public TeamController()
{
this.repo = new TeamRepository();
}
public void GetTeamById()
{
var repo = new TeamRepository();
var y = repo.GetById(2);
Assert.IsTrue(y.Players.Count > 0);
}
public string GetSociaoQueueMessageByUserIdAndGroupId(string UserId, string GroupId)
{
string profileid = string.Empty;
TeamRepository objTeamRepository = new TeamRepository();
try
{
Guid userid = Guid.Parse(UserId);
Guid groupid = Guid.Parse(GroupId);
List<Domain.Myfashion.Domain.ScheduledMessage> lstfianlscoailqueue = new List<Domain.Myfashion.Domain.ScheduledMessage>();
Domain.Myfashion.Domain.Team objTeam = objTeamRepository.GetTeamByGroupId(groupid);
List<Domain.Myfashion.Domain.TeamMemberProfile> allprofiles = objTeamMemberProfileRepository.getAllTeamMemberProfilesOfTeam(objTeam.Id);
ScheduledMessageRepository objScheduledMessageRepository = new ScheduledMessageRepository();
List<Domain.Myfashion.Domain.ScheduledMessage> lstScheduledMessages = new List<Domain.Myfashion.Domain.ScheduledMessage>();
Dictionary<string, List<Domain.Myfashion.Domain.ScheduledMessage>> objdic = new Dictionary<string, List<Domain.Myfashion.Domain.ScheduledMessage>>();
foreach (var item in allprofiles)
{
lstScheduledMessages = objScheduledMessageRepository.getAllMessagesDetail(item.ProfileId, userid);
if (lstScheduledMessages.Count > 0)
{
objdic.Add(item.ProfileId, lstScheduledMessages);
}
}
foreach (var item in objdic)
{
foreach (var ScheduledMessage in item.Value)
{
lstfianlscoailqueue.Add(ScheduledMessage);
}
}
//FacebookAccountRepository facebookAccountRepo = new FacebookAccountRepository();
// FacebookAccount facebook = facebookAccountRepo.getFacebookAccountDetailsById(FacebookId, userid);
return new JavaScriptSerializer().Serialize(lstfianlscoailqueue);
}
catch (Exception ex)
{
logger.Error(ex.Message);
Console.WriteLine(ex.StackTrace);
return new JavaScriptSerializer().Serialize("Please try Again");
}
}
public void TeamRepositoryConstructorTest4()
{
string connectionString = string.Empty; // TODO: Initialize to an appropriate value
TeamRepository target = new TeamRepository(connectionString);
Assert.Inconclusive("TODO: Implement code to verify target");
}
public void SaveTeam()
{
txtTeamNumber.Text = txtTeamNumber.Text.PadLeft(2, Convert.ToChar("0"));
var rep = new TeamRepository(new CSBCDbContext());
Team team;
if (TeamId == 0)
{
//new team
team = new Team();
}
else
{
//existing team
team = rep.GetById(TeamId);
}
team.TeamName = txtName.Text;
team.TeamNumber = txtTeamNumber.Text;
team.TeamColorID = Int32.Parse(cmbColors.SelectedValue);
if (cmbCoach.SelectedValue != "")
team.CoachID = Int32.Parse(cmbCoach.SelectedValue);
team.DivisionID = Int32.Parse(cmbDivisions.SelectedValue);
Master.DivisionId = team.DivisionID;
if (cmbAsstCoach.SelectedValue != "")
team.AssCoachID = Int32.Parse(cmbAsstCoach.SelectedValue);
//_with12.SponsorID = Int32.Parse(cmbSponsors.SelectedValue);
///put this back
team.CompanyID = Master.CompanyId;
team.CreatedUser = (string)Session["UserName"];
team.SeasonID = (int)Session["SeasonID"];
if (team.TeamID == 0)
{
var newTeam = rep.Insert(team);
//lblTeamId.Value = TeamId.ToString();
}
else
rep.Update(team);
lblError.Text = "Changes successfully completed";
LoadTeams(Master.DivisionId);
//LoadColors();
//Call LoadCoaches()
//LoadRow((long)Session["TeamID"]);
}
public void GetTeamByNameTest()
{
TeamRepository target = new TeamRepository(); // TODO: Initialize to an appropriate value
string name = string.Empty; // TODO: Initialize to an appropriate value
Team expected = null; // TODO: Initialize to an appropriate value
Team actual;
actual = target.GetTeamByName(name);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public void GetTeamsByLeadTest()
{
TeamRepository target = new TeamRepository(); // TODO: Initialize to an appropriate value
string teamLeadEmail = string.Empty; // TODO: Initialize to an appropriate value
IList<Team> expected = null; // TODO: Initialize to an appropriate value
IList<Team> actual;
actual = target.GetTeamsByLead(teamLeadEmail);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public void TeamRepositoryConstructorTest2()
{
ISession session = null; // TODO: Initialize to an appropriate value
TeamRepository target = new TeamRepository(session);
Assert.Inconclusive("TODO: Implement code to verify target");
}
public void TeamRepositoryConstructorTest3()
{
TeamRepository target = new TeamRepository();
Assert.Inconclusive("TODO: Implement code to verify target");
}
public void GetTeamPlayersTest()
{
var context = new CSBC.Core.Data.CSBCDbContext();
var rep = new PlayerRepository(context);
var repTeam = new TeamRepository(context);
//var seasonId = repSeason.GetCurrentSeason(1).SeasonID;
var players = rep.GetTeamPlayers(5954); //test value
Assert.IsTrue(players.Count<SeasonPlayer>() > 0);
}
public void TeamRepository()
{
Mock<IDbSetFactory> factory = new Mock<IDbSetFactory>();
Mock<DbSet<Team>> dbSet = new Mock<DbSet<Team>>();
factory.Setup(m => m.CreateDbSet<Team>()).Returns(dbSet.Object);
TeamRepository repo = new TeamRepository(factory.Object);
var Team = new Team();
var sequence = new MockSequence();
dbSet.InSequence(sequence).Setup(e => e.Add(Team));
dbSet.InSequence(sequence).Setup(e => e.Find(Team.Id));
dbSet.InSequence(sequence).Setup(e => e.Find(Team.Id));
dbSet.InSequence(sequence).Setup(e => e.Find(Team.Id));
repo.Create(Team);
repo.Get(Team.Id);
repo.Update(Team);
repo.Delete(Team.Id);
}
