public async Task GetsTeamsSize()
{
using (var context = new ApplicationDbContext(_options))
{
context.Teams.AddRange(
new Team {
Id = 1
},
new Team {
Id = 2
},
new Team {
Id = 3
});
context.SaveChanges();
}
using (var context = new ApplicationDbContext(_options))
{
var teamsRepository = new TeamsRepository(context);
var teamsSize = await teamsRepository.GetSize(null);
Assert.Equal(3, teamsSize);
}
}
private void AddTeam(Team teamBdo)
{
var teamEntity = new TeamEntity()
{
SeasonId = _seasonId,
WeekOffset = _weekOffset,
PremierLeagueTeamId = teamBdo.id,
TeamName = teamBdo.name,
CreatedDateTimeUtc = DateTime.UtcNow
};
// TODO: Exception handling.
TeamsRepository.Create(teamEntity);
TeamsRepository.SaveChanges();
var teamPlayers = GetTeamPlayers(teamBdo);
_teamSequenceIndex = 0;
foreach (var playerTypePair in _fantasyFootballBdo.PlayerTypes)
{
AddTeamPlayer(teamEntity, playerTypePair.Value, teamPlayers);
}
PlayersRepository.SaveChanges();
}
public void RemoveTeam_Test()
{
//Arrange
var options = new DbContextOptionsBuilder <TeamContext>().UseInMemoryDatabase($"TeamContext_{ Guid.NewGuid() }").Options;
using (var context = new TeamContext(options))
{
context.Add(new Team()
{
Id = 1,
City = "Chicago",
Name = "Chicago Fire",
DateOfFoundation = DateTime.Now
});
context.Add(new Team()
{
Id = 2,
City = "Los Angeles",
Name = "Los Angeles Galaxy",
DateOfFoundation = DateTime.Now
});
context.SaveChanges();
var repository = new TeamsRepository(context);
//Act
repository.RemoveTeam(1);
var teams = repository.GetTeams().ToList();
//Assert
Assert.Equal(1, teams.Count);
}
}
public void Create(FantasyFootballBdo fantasyFootballBdo)
{
var utcNow = DateTime.UtcNow;
var seasonEntity = SeasonsRepository.Get(utcNow);
if (seasonEntity == null)
{
throw new Exception($"There is no Fantasy Football Season covering the Date = {utcNow:yyyy-MMM-dd}.");
}
_seasonId = seasonEntity.SeasonId;
_weekOffset = DateTimeHelper.GetWeekOffset(seasonEntity, utcNow);
var teamEntity = TeamsRepository.GetFirstOrDefault(entity => (entity.SeasonId == _seasonId) && (entity.WeekOffset == _weekOffset));
if (teamEntity != null)
{
throw new Exception($"There already exists a Weekly Results Set covering the Date = {utcNow:yyyy-MMM-dd}, otherwise known as Season Id = {_seasonId} and Week Offset = {_weekOffset}.");
}
_fantasyFootballBdo = fantasyFootballBdo;
foreach (var teamBdoPair in _fantasyFootballBdo.Teams)
{
AddTeam(teamBdoPair.Value);
}
}
public OctopusAsyncRepository(IOctopusAsyncClient client, RepositoryScope repositoryScope = null)
{
Client = client;
Scope = repositoryScope ?? RepositoryScope.Unspecified();
Accounts = new AccountRepository(this);
ActionTemplates = new ActionTemplateRepository(this);
Artifacts = new ArtifactRepository(this);
Backups = new BackupRepository(this);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(this);
CertificateConfiguration = new CertificateConfigurationRepository(this);
Certificates = new CertificateRepository(this);
Channels = new ChannelRepository(this);
CommunityActionTemplates = new CommunityActionTemplateRepository(this);
Configuration = new ConfigurationRepository(this);
DashboardConfigurations = new DashboardConfigurationRepository(this);
Dashboards = new DashboardRepository(this);
Defects = new DefectsRepository(this);
DeploymentProcesses = new DeploymentProcessRepository(this);
Deployments = new DeploymentRepository(this);
Environments = new EnvironmentRepository(this);
Events = new EventRepository(this);
FeaturesConfiguration = new FeaturesConfigurationRepository(this);
Feeds = new FeedRepository(this);
Interruptions = new InterruptionRepository(this);
LibraryVariableSets = new LibraryVariableSetRepository(this);
Lifecycles = new LifecyclesRepository(this);
MachinePolicies = new MachinePolicyRepository(this);
MachineRoles = new MachineRoleRepository(this);
Machines = new MachineRepository(this);
Migrations = new MigrationRepository(this);
OctopusServerNodes = new OctopusServerNodeRepository(this);
PerformanceConfiguration = new PerformanceConfigurationRepository(this);
PackageMetadataRepository = new PackageMetadataRepository(this);
ProjectGroups = new ProjectGroupRepository(this);
Projects = new ProjectRepository(this);
ProjectTriggers = new ProjectTriggerRepository(this);
Proxies = new ProxyRepository(this);
Releases = new ReleaseRepository(this);
RetentionPolicies = new RetentionPolicyRepository(this);
Schedulers = new SchedulerRepository(this);
ServerStatus = new ServerStatusRepository(this);
Spaces = new SpaceRepository(this);
Subscriptions = new SubscriptionRepository(this);
TagSets = new TagSetRepository(this);
Tasks = new TaskRepository(this);
Teams = new TeamsRepository(this);
Tenants = new TenantRepository(this);
TenantVariables = new TenantVariablesRepository(this);
UserInvites = new UserInvitesRepository(this);
UserRoles = new UserRolesRepository(this);
Users = new UserRepository(this);
VariableSets = new VariableSetRepository(this);
Workers = new WorkerRepository(this);
WorkerPools = new WorkerPoolRepository(this);
ScopedUserRoles = new ScopedUserRoleRepository(this);
UserPermissions = new UserPermissionsRepository(this);
loadRootResource = new Lazy <Task <RootResource> >(LoadRootDocumentInner, true);
loadSpaceRootResource = new Lazy <Task <SpaceRootResource> >(LoadSpaceRootDocumentInner, true);
}
public TeamsService(TeamsRepository teamsRepository,
TopicService <GameMessageModel> topicService, TelemetryService telemetryService)
{
_teamsRepository = teamsRepository;
_topicService = topicService;
_telemetryService = telemetryService;
}
public ActionResult Add(Team team)
{
if (!String.IsNullOrWhiteSpace(team.TeamName))
{
TeamsRepository teamsrep = new TeamsRepository();
if (teamsrep.GetAllTeams().Where(k => k.TeamName.ToLower() == team.TeamName.ToLower()).Count() > 0)
{
ModelState.AddModelError("TeamName", "That team name is already in use");
}
else
{
teamsrep.Add(team);
teamsrep.SaveChanges();
return(Redirect("/teams"));
}
}
else
{
ModelState.AddModelError("TeamName", "Please enter a team name");
}
return(View(team));
}
public PlayersService(TeamsRepository teamsRepository,
ImagesService imagesService, BinaryFilesRepository binaryFilesRepository)
{
_teamsRepository = teamsRepository;
_imagesService = imagesService;
_binaryFilesRepository = binaryFilesRepository;
}
public async Task GetsTeamById()
{
using (var context = new ApplicationDbContext(_options))
{
context.Teams.AddRange(
new Team {
Id = 1
},
new Team {
Id = 2
});
context.SaveChanges();
}
using (var context = new ApplicationDbContext(_options))
{
var teamsRepository = new TeamsRepository(context);
var team = await teamsRepository.GetById(1);
var team2 = await teamsRepository.GetById(2);
Assert.NotNull(team);
Assert.NotNull(team2);
Assert.Equal(1, team.Id);
Assert.Equal(2, team2.Id);
}
}
public ResultController(ScoresRepository scoresRepository, MatchesRespository matchesRespository, TeamsRepository teamsRepository, ResultsRepository resultsRepository)
{
_scoresRepository = scoresRepository;
_matchesRespository = matchesRespository;
_teamsRepository = teamsRepository;
_resultsRepository = resultsRepository;
}
public async Task GetsTeams()
{
using (var context = new ApplicationDbContext(_options))
{
context.Teams.AddRange(
new Team {
Id = 1
},
new Team {
Id = 2
},
new Team {
Id = 3
});
context.SaveChanges();
}
using (var context = new ApplicationDbContext(_options))
{
var teamsRepository = new TeamsRepository(context);
var teams = await teamsRepository.GetAll(0, 2, null);
Assert.Equal(2, teams.Count);
Assert.NotNull(teams.SingleOrDefault(x => x.Id == 1));
Assert.NotNull(teams.SingleOrDefault(x => x.Id == 2));
}
}
public IActionResult OnGet()
{
if (HttpContext.Session.GetString("EventId") == null)
{
string returnUrl = HttpContext.Request.Path.ToString();
return(RedirectToPage("/Account/Login", new { area = "Identity" }));
}
ViewData["IsParticipating"] = HttpContext.Session.GetString("IsParticipating");
int eventId = int.Parse(HttpContext.Session.GetString("EventId"), CultureInfo.CurrentCulture);
ViewData["EventId"] = eventId;
DinnerEvent dinnerEvent = DinnerEventsRepository.GetById(eventId);
if (dinnerEvent != null)
{
// Values are passed-through to layout page
ViewData["EventName"] = dinnerEvent.EventName;
ViewData["EventDate"] = dinnerEvent.EventDate.ToShortDateString();
ViewData["EventCity"] = dinnerEvent.City;
ViewData["EventPictureLink"] = dinnerEvent.EventPictureLink;
}
List <Team> teams = TeamsRepository.SearchFor(x => x.Event.Id == eventId).Include("Partner1").Include("Partner2").ToList();
Teams = teams;
return(Page());
}
public ChoiceViewModel(choiceDto cd, string encryptedKey)
{
this.choiceSn = cd.sn;
this.choiceStr = cd.choiceStr;
this.comment = cd.comment;
this.betMoney = cd.betMoneygti;
this.betball = Math.Round(this.betMoney / 10000, 2);
this.Odds = cd.Odds;
this.betModel = cd.betModel;
this.dragonshort = cd.dragonshort;
this.encryptedKey = encryptedKey;
var teams = new TeamsRepository().getImg(cd.choiceStr);
if (teams != null)
{
this.teamimg = teams.imageURL;
}
if (cd.betMoney != null)
{
this.betMoneycount = cd.betMoney.Count();
}
else
{
this.betMoneycount = 0;
}
}
public void Init(EventsRepository evRep,
TeamsRepository teamsRepository,
int id)
{
Tr = teamsRepository;
Event = evRep.Get(id);
Teams = Event.Teams;
}
public ActionResult Edit(int?id)
{
//var tm = db.Teams.Where(t => t.TeamId == id).FirstOrDefault
TeamsRepository TeamsRep = new TeamsRepository();
var myteams = TeamsRep.GetAllTeams().SingleOrDefault(t => t.Id == id);
return(View(myteams));
}
public void CannotSwitchSpaceContextWhenTheRepositoryScopeIsSpecified(RepositoryScope scope)
{
var repository = Substitute.For <IOctopusAsyncRepository>();
repository.Scope.Returns(scope);
ITeamsRepository teamRepo = new TeamsRepository(repository);
Action switchContext = () => teamRepo.UsingContext(SpaceContext.AllSpaces());
switchContext.ShouldThrow <SpaceContextSwitchException>();
}
public ActionResult Add(Match match)
{
List <SelectListItem> teamlist = new List <SelectListItem>();
TeamsRepository teamsrep = new TeamsRepository();
var myteams = teamsrep.GetAllTeams().OrderBy(k => k.TeamName);
if (myteams.Count() > 0)
{
foreach (Team t in myteams)
{
SelectListItem sli = new SelectListItem();
sli.Value = t.Id.ToString();
sli.Text = t.TeamName;
teamlist.Add(sli);
}
}
ViewData["Teams"] = teamlist;
if (match.HomeGoals != null)
{
if (match.AwayGoals != null)
{
if (match.Timestamp != null)
{
if (match.HomeTeamId != match.AwayTeamId)
{
MatchesRepository matchesrep = new MatchesRepository();
matchesrep.Add(match);
matchesrep.SaveChanges();
return(Redirect("/matches"));
}
else
{
ModelState.AddModelError("HomeTeamId", "Please make sure that the teams are different for home and away sides");
ModelState.AddModelError("AwayTeamId", "Please make sure that the teams are different for home and away sides");
}
}
else
{
ModelState.AddModelError("Timestamp", "Please make sure you've entered a valid date for this match");
}
}
else
{
ModelState.AddModelError("AwayGoals", "Please make sure you've entered the number of goals that the away team scored");
}
}
else
{
ModelState.AddModelError("HomeGoals", "Please make sure you've entered the number of goals that the home team scored");
}
return(View());
}
public ActionResult All()
{
TeamsRepository teamsrep = new TeamsRepository();
var myteams = teamsrep.GetAllTeams();
if (myteams.Count() > 0)
{
ViewData["MyTeams"] = myteams.OrderBy(t => t.Name);
}
return(View());
}
public void Verify_Add_Should_AddTheEntityToTheContext()
{
// Arrange
Mock<IDbSet<Team>> mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(false, out mockSetTeams);
var repository = new TeamsRepository(mockContext.Object);
var teams = new Team { Active = true, CustomKey = "SALVATORE-RAA", };
// Act
repository.Add(teams);
// Assert
mockSetTeams.Verify(x => x.Add(teams), Times.Once);
}
public void Verify_Deactivate_Should_SetTheActivePropertyToFalseOnTheEntity()
{
// Arrange
Mock<IDbSet<Team>> mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(true, out mockSetTeams);
var repository = new TeamsRepository(mockContext.Object);
var teams = repository.Get(1);
// Act
repository.Deactivate(teams);
// Assert
Assert.Equal(false, teams.Active);
}
public void Verify_Get_ByKey_Should_ReturnTheCorrectTeam()
{
// Arrange
Mock <IDbSet <Team> > mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(true, out mockSetTeams);
var repository = new TeamsRepository(mockContext.Object);
// Act
var teams = repository.Get("KING-STEPHEN");
// Assert
Assert.Equal("/TEST/KING-STEPHEN", teams.ApiDetailUrl);
}
public OctopusAsyncRepository(IOctopusAsyncClient client)
{
this.Client = client;
Accounts = new AccountRepository(client);
ActionTemplates = new ActionTemplateRepository(client);
Artifacts = new ArtifactRepository(client);
Backups = new BackupRepository(client);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(client);
CertificateConfiguration = new CertificateConfigurationRepository(client);
Certificates = new CertificateRepository(client);
Channels = new ChannelRepository(client);
CommunityActionTemplates = new CommunityActionTemplateRepository(client);
Configuration = new ConfigurationRepository(client);
DashboardConfigurations = new DashboardConfigurationRepository(client);
Dashboards = new DashboardRepository(client);
Defects = new DefectsRepository(client);
DeploymentProcesses = new DeploymentProcessRepository(client);
Deployments = new DeploymentRepository(client);
Environments = new EnvironmentRepository(client);
Events = new EventRepository(client);
FeaturesConfiguration = new FeaturesConfigurationRepository(client);
Feeds = new FeedRepository(client);
Interruptions = new InterruptionRepository(client);
LibraryVariableSets = new LibraryVariableSetRepository(client);
Lifecycles = new LifecyclesRepository(client);
MachinePolicies = new MachinePolicyRepository(client);
MachineRoles = new MachineRoleRepository(client);
Machines = new MachineRepository(client);
Migrations = new MigrationRepository(client);
OctopusServerNodes = new OctopusServerNodeRepository(client);
PerformanceConfiguration = new PerformanceConfigurationRepository(client);
ProjectGroups = new ProjectGroupRepository(client);
Projects = new ProjectRepository(client);
ProjectTriggers = new ProjectTriggerRepository(client);
Proxies = new ProxyRepository(client);
Releases = new ReleaseRepository(client);
RetentionPolicies = new RetentionPolicyRepository(client);
Schedulers = new SchedulerRepository(client);
ServerStatus = new ServerStatusRepository(client);
Subscriptions = new SubscriptionRepository(client);
TagSets = new TagSetRepository(client);
Tasks = new TaskRepository(client);
Teams = new TeamsRepository(client);
Tenants = new TenantRepository(client);
TenantVariables = new TenantVariablesRepository(client);
UserRoles = new UserRolesRepository(client);
Users = new UserRepository(client);
VariableSets = new VariableSetRepository(client);
Workers = new WorkerRepository(client);
WorkerPools = new WorkerPoolRepository(client);
}
public ActionResult View(int Id)
{
TeamsRepository teamsrep = new TeamsRepository();
var allteams = teamsrep.GetAllTeams().Where(k => k.Id != Id).OrderBy(k => k.TeamName);
if (allteams.Count() > 0)
{
ViewData["AllTeams"] = allteams;
}
var team = teamsrep.GetAllTeams().Where(k => k.Id == Id).FirstOrDefault();
if (team != null)
{
MatchReportRepository matchreportrep = new MatchReportRepository();
var allreports = matchreportrep.GetAllReports().Where(k => k.Match.HomeTeamId == Id || k.Match.AwayTeamId == Id).OrderByDescending(k => k.Match.Timestamp);
if (Request.QueryString["opponent"] != null)
{
var opponent = allteams.Where(k => k.Id.ToString() == Request.QueryString["opponent"].ToString()).FirstOrDefault();
if (opponent != null)
{
ViewData["OpponentTeamName"] = opponent.TeamName;
allreports = allreports.Where(k => k.Match.HomeTeamId == opponent.Id || k.Match.AwayTeamId == opponent.Id).OrderByDescending(k => k.Match.Timestamp);
}
}
var allhomegames = allreports.Where(k => k.Match.HomeTeamId == Id);
var allawaygames = allreports.Where(k => k.Match.AwayTeamId == Id);
if (allhomegames.Count() > 0)
{
ViewData["HomeGames"] = allhomegames;
}
if (allawaygames.Count() > 0)
{
ViewData["AwayGames"] = allawaygames;
}
return(View(team));
}
else
{
return(Redirect("/"));
}
}
public void Verify_Deactivate_Should_SetTheActivePropertyToFalseOnTheEntity()
{
// Arrange
Mock <IDbSet <Team> > mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(true, out mockSetTeams);
var repository = new TeamsRepository(mockContext.Object);
var teams = repository.Get(1);
// Act
repository.Deactivate(teams);
// Assert
Assert.Equal(false, teams.Active);
}
public async Task NonSingleSpaceContextShouldNotChangeExistingSpaceId(string spaceIdsToUse, bool includeSystem)
{
var spaceIds = spaceIdsToUse.Split(',');
var client = SetupAsyncClient();
await client.Create(Arg.Any <string>(), Arg.Do <TeamResource>(t => t.SpaceId.Should().Be("Spaces-4"))).ConfigureAwait(false);
var teamRepo = new TeamsRepository(new OctopusAsyncRepository(client, RepositoryScope.Unspecified()));
var multiScoped = teamRepo.UsingContext(SpaceContext.SpecificSpacesAndSystem(spaceIds.Select(CreateSpaceResource)));
var _ = await multiScoped.Create(new TeamResource()
{
Name = "Test", SpaceId = "Spaces-4"
}).ConfigureAwait(false);
}
public void Verify_Remove_Should_RemoveTheEntityFromTheContext()
{
// Arrange
Mock <IDbSet <Team> > mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(true, out mockSetTeams);
var repository = new TeamsRepository(mockContext.Object);
var teams = repository.Get(1);
// Act
repository.Remove(teams);
// Assert
mockSetTeams.Verify(x => x.Remove((Team)teams), Times.Once);
}
public ActionResult View(int Id)
{
TeamsRepository TeamsRep = new TeamsRepository();
var allteams = TeamsRep.GetAllTeams().Where(t => t.Id != Id).OrderBy(t => t.Name);
if (allteams.Count() > 0)
{
ViewData["AllTeams"] = allteams;
}
var myteam = TeamsRep.GetAllTeams().Where(t => t.Id == Id).FirstOrDefault();
if (myteam != null)
{
PlayersRepository playerrep = new PlayersRepository();
ReportsRepository ReportRep = new ReportsRepository();
var allreports = ReportRep.GetAllReports().Where(r => r.Match.Fixture.HomeTeamId == Id || r.Match.Fixture.AwayTeamId == Id).OrderByDescending(r => r.Match.Fixture.TimeStamp);
if (Request.QueryString["opponent"] != null)
{
var opponent = allteams.Where(t => t.Id.ToString() == Request.QueryString["opponent"].ToString()).FirstOrDefault();
if (opponent != null)
{
ViewData["OpponentTeamName"] = opponent.Name;
allreports = allreports.Where(k => k.Match.Fixture.HomeTeamId == opponent.Id || k.Match.Fixture.AwayTeamId == opponent.Id).OrderByDescending(k => k.Match.Fixture.TimeStamp);
///return
}
}
var allhomegames = allreports.Where(h => h.Match.Fixture.HomeTeamId == Id);
var allawaygames = allreports.Where(h => h.Match.Fixture.AwayTeamId == Id);
if (allhomegames.Count() > 0)
{
ViewData["HomeGames"] = allhomegames;
}
if (allawaygames.Count() > 0)
{
ViewData["AwayGames"] = allawaygames;
}
return(View(myteam));
}
else
{
return(Redirect("/"));
}
}
public async Task MixedScoped_SingleSpaceContextShouldEnrichSpaceId(string spaceId)
{
var client = SetupAsyncClient();
await client.Create(Arg.Any <string>(), Arg.Do <TeamResource>(t =>
{
t.SpaceId.Should().Be(spaceId);
})).ConfigureAwait(false);
var teamRepo = new TeamsRepository(new OctopusAsyncRepository(client, RepositoryScope.ForSpace(CreateSpaceResource(spaceId))));
var created = await teamRepo.Create(new TeamResource()
{
Name = "Test"
}).ConfigureAwait(false);
}
public void Verify_Update_Should_SetTheEntityStateToModified()
{
// Arrange
Mock <IDbSet <Team> > mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(true, out mockSetTeams);
var repository = new TeamsRepository(mockContext.Object);
var teams = repository.Get(1);
teams.ApiDetailUrl = "/TEST";
// Act
repository.Update(teams);
// Assert
mockContext.Verify(x => x.SetModified(It.IsAny <object>()), Times.Once);
}
static void Main(string[] args)
{
ITeamsRepository teamsRepo = new TeamsRepository();
IBracketGenerator bracketGenerator = new BracketGenerator();
IMatchupService matchupService = new MatchupService();
IWinnersService winnersService = new WinnersService();
var roundOf64Teams = teamsRepo.GetTeams();
var roundOf64Matchups = matchupService.GetMatchups(roundOf64Teams);
ValidateMatchupCount(32, roundOf64Matchups.Count);
var roundOf64Winners = winnersService.PredictWinners(roundOf64Matchups);
var roundOf32Matchups = matchupService.GetMatchups(roundOf64Winners);
ValidateMatchupCount(16, roundOf32Matchups.Count);
var roundOf32Winners = winnersService.PredictWinners(roundOf32Matchups);
var sweetSixteenMatchups = matchupService.GetMatchups(roundOf32Winners);
ValidateMatchupCount(8, sweetSixteenMatchups.Count);
var sweetSixteenWinners = winnersService.PredictWinners(sweetSixteenMatchups);
var eliteEightMatchups = matchupService.GetMatchups(sweetSixteenWinners);
ValidateMatchupCount(4, eliteEightMatchups.Count);
var eliteEightWinners = winnersService.PredictWinners(eliteEightMatchups);
var finalFourMatchups = matchupService.GetMatchups(eliteEightWinners);
ValidateMatchupCount(2, finalFourMatchups.Count);
var finalFourWinners = winnersService.PredictWinners(finalFourMatchups);
var championshipMatchup = matchupService.GetMatchups(finalFourWinners);
ValidateMatchupCount(1, championshipMatchup.Count);
var championshipWinner = winnersService.PredictWinners(championshipMatchup);
var allMatchups = roundOf64Matchups.Concat(roundOf32Matchups).Concat(sweetSixteenMatchups)
.Concat(eliteEightMatchups).Concat(finalFourMatchups).Concat(championshipMatchup).ToList();
var allWinners = roundOf64Winners.Concat(roundOf32Winners).Concat(sweetSixteenWinners)
.Concat(eliteEightWinners).Concat(finalFourWinners).Concat(championshipWinner).ToList();
bracketGenerator.GenerateBracket(allMatchups, allWinners);
Console.WriteLine("Your bracket has been generated. Press [enter] to exit.");
Console.ReadLine();
}
public ActionResult Add(Team team)
{
List <SelectListItem> venuelist = new List <SelectListItem>();
VenuesRepository VenuesRep = new VenuesRepository();
var myvenues = VenuesRep.GetAllVenues().OrderBy(k => k.Name);
TeamsRepository teamsrep = new TeamsRepository();
//--- string fileName = Path.GetFileNameWithoutExtension(team.ImageUpload.FileName);
// string extension = Path.GetExtension(team.ImageUpload.FileName);
//fileName = fileName + DateTime.Now.ToString("yymmssff") + extension;
// team.LogoUrl = "~/Content/images/" + fileName;
// fileName = Path.Combine(Server.MapPath("~/Content/images/"), fileName);
// team.ImageUpload.SaveAs(fileName);
if (myvenues.Count() > 0)
{
foreach (Venue v in myvenues)
{
SelectListItem sli = new SelectListItem();
sli.Value = v.Id.ToString();
sli.Text = v.Name;
venuelist.Add(sli);
}
}
ViewData["Venues"] = venuelist;
if (!String.IsNullOrWhiteSpace(team.Name))
{
if (teamsrep.GetAllTeams().Where(k => k.Name.ToLower() == team.Name.ToLower()).Count() > 0)
{
ModelState.AddModelError("Name", "That team name is already in use");
}
else
{
teamsrep.Add(team);
teamsrep.SaveChanges();
return(Redirect("/teams"));
}
}
else
{
//No team entered
ModelState.AddModelError("Name", "Please enter team name");
}
return(View(team));
}
public string Create()
{
string resultFile = null;
var utcNow = DateTime.UtcNow;
var seasonEntity = SeasonsRepository.Get(utcNow);
if (seasonEntity == null)
{
throw new Exception($"There is no Fantasy Football Season covering the Date = {utcNow:yyyy-MMM-dd}.");
}
_seasonId = seasonEntity.SeasonId;
_weekOffset = DateTimeHelper.GetWeekOffset(seasonEntity, utcNow);
var firstResultsSet = TeamsRepository.GetFirstOrDefault(entity => (entity.SeasonId == _seasonId) && (entity.WeekOffset == _weekOffset));
if (firstResultsSet == null)
{
throw new Exception($"There is no Weekly Results Set covering the Date = {utcNow:yyyy-MMM-dd}, otherwise known as Season Id = {_seasonId} and Week Offset = {_weekOffset}.");
}
_document = new Document();
var teamEntities = TeamsRepository
.GetAll(_seasonId, _weekOffset);
foreach (var teamEntity in teamEntities)
{
AddTeam(teamEntity);
}
HeaderFooter footer = _document.Sections[0].HeadersFooters.Footer;
Paragraph footerParagraph = footer.AddParagraph();
var textRange = footerParagraph.AppendText($"Season Id = {_seasonId} : Week Offset = {_weekOffset} : Page ");
textRange.CharacterFormat.FontName = "Calibri";
textRange = footerParagraph.AppendField("page number", FieldType.FieldPage);
textRange.CharacterFormat.FontName = "Calibri";
footerParagraph.Format.HorizontalAlignment = HorizontalAlignment.Center;
resultFile = $"Fantasy Football Assistant - {DateTime.UtcNow:yyyy-MMM-dd}.docx";
_document.SaveToFile($"wwwroot\\{resultFile}", FileFormat.Docx2013);
return(resultFile);
}
public OctopusRepository(IOctopusClient client)
{
this.Client = client;
Feeds = new FeedRepository(client);
Backups = new BackupRepository(client);
Machines = new MachineRepository(client);
MachineRoles = new MachineRoleRepository(client);
MachinePolicies = new MachinePolicyRepository(client);
Subscriptions = new SubscriptionRepository(client);
Environments = new EnvironmentRepository(client);
Events = new EventRepository(client);
FeaturesConfiguration = new FeaturesConfigurationRepository(client);
ProjectGroups = new ProjectGroupRepository(client);
Projects = new ProjectRepository(client);
Proxies = new ProxyRepository(client);
Tasks = new TaskRepository(client);
Users = new UserRepository(client);
VariableSets = new VariableSetRepository(client);
LibraryVariableSets = new LibraryVariableSetRepository(client);
DeploymentProcesses = new DeploymentProcessRepository(client);
Releases = new ReleaseRepository(client);
Deployments = new DeploymentRepository(client);
Certificates = new CertificateRepository(client);
Dashboards = new DashboardRepository(client);
DashboardConfigurations = new DashboardConfigurationRepository(client);
Artifacts = new ArtifactRepository(client);
Interruptions = new InterruptionRepository(client);
ServerStatus = new ServerStatusRepository(client);
UserRoles = new UserRolesRepository(client);
Teams = new TeamsRepository(client);
RetentionPolicies = new RetentionPolicyRepository(client);
Accounts = new AccountRepository(client);
Defects = new DefectsRepository(client);
Lifecycles = new LifecyclesRepository(client);
OctopusServerNodes = new OctopusServerNodeRepository(client);
Channels = new ChannelRepository(client);
ProjectTriggers = new ProjectTriggerRepository(client);
Schedulers = new SchedulerRepository(client);
Tenants = new TenantRepository(client);
TagSets = new TagSetRepository(client);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(client);
ActionTemplates = new ActionTemplateRepository(client);
CommunityActionTemplates = new CommunityActionTemplateRepository(client);
}
public void Verify_Get_ByID_Should_ReturnTheCorrectTeam()
{
// Arrange
Mock<IDbSet<Team>> mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(true, out mockSetTeams);
var repository = new TeamsRepository(mockContext.Object);
// Act
var teams = repository.Get(1);
// Assert
Assert.Equal("/TEST/KING-STEPHEN", teams.ApiDetailUrl);
}
public void Verify_Search_WithModifiedSince_Should_ReturnAListOfTeamsWithDataMatchingSearchParameters()
{
// Arrange
Mock<IDbSet<Team>> mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(true, out mockSetTeams, true);
var repository = new TeamsRepository(mockContext.Object);
var createDate = new System.DateTime(2015, 05, 28, 10, 45, 00).AddDays(1).AddMinutes(-1);
//var searchModel = new Mock<ITeamSearchModel>();
//searchModel.Setup(m => m.ModifiedSince).Returns(() => createDate);
var searchModel = new TeamSearchModel { ModifiedSince = createDate };
// Act
var teams = repository.Search(searchModel/*.Object*/).ToArray();
// Assert
Assert.Equal(1, teams.Length);
Assert.Equal(2, teams[0].Id);
Assert.Equal("/TEST/NIVEN-LARRY", teams[0].ApiDetailUrl);
// Stephen King was filtered out because he was created before the modified since date
}
public void Verify_Search_WithPaging_Should_ReturnAListOfTeamsWithDataMatchingSearchParameters()
{
// Arrange
Mock<IDbSet<Team>> mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(true, out mockSetTeams);
var repository = new TeamsRepository(mockContext.Object);
var searchModel = new TeamSearchModel { Paging = new Paging { Skip = 1, Take = 1 } };
// Act
var teams = repository.Search(searchModel/*.Object*/).ToArray();
// Assert
Assert.Equal(1, teams.Length);
Assert.Equal(2, teams[0].Id);
Assert.Equal("/TEST/NIVEN-LARRY", teams[0].ApiDetailUrl);
// Stephen King was filtered out because he was Skipped
}
public void Verify_Search_WithSelectStatement_Should_ReturnAListOfDynamicObjects()
{
// Arrange
Mock<IDbSet<Team>> mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(true, out mockSetTeams, true);
var repository = new TeamsRepository(mockContext.Object);
var searchModel = new Mock<ITeamSearchModel>();
// Act
var teams = repository.Search(searchModel.Object, i => new { i.Id, MyApiDetailUrl = i.ApiDetailUrl }).ToArray();
// Assert
Assert.Equal(1, teams.Length);
Assert.Equal(2, teams[0].Id);
Assert.Equal("/TEST/NIVEN-LARRY", teams[0].MyApiDetailUrl);
// Stephen King was filtered out because he was Inactive
}
public void Verify_Update_Should_SetTheEntityStateToModified()
{
// Arrange
Mock<IDbSet<Team>> mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(true, out mockSetTeams);
var repository = new TeamsRepository(mockContext.Object);
var teams = repository.Get(1);
teams.ApiDetailUrl = "/TEST";
// Act
repository.Update(teams);
// Assert
mockContext.Verify(x => x.SetModified(It.IsAny<object>()), Times.Once);
}
protected void InitDataObjects()
{
eventsRepo = new EventsRepository();
scoreMethodRepo = new ScoreMethodRepository();
seriesRepo = new SeriesRepository();
teamsRepo = new TeamsRepository();
eventTeamsRepo = new EventTeamsRepository();
playersRepo = new PlayersRepository();
eventPlayersRepo = new EventPlayersRepository();
matchRepo = new MatchesRepository();
matchTeamsRepo = new MatchTeamsRepository();
packsetRepo = new PacksetsRepository();
matchPlayerRepo = new MatchPlayersRepository();
}
public void Verify_List_Should_ReturnAListOfTeamsWithData()
{
// Arrange
Mock<IDbSet<Team>> mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(true, out mockSetTeams);
var repository = new TeamsRepository(mockContext.Object);
// Act
var teams = repository.List.ToArray();
// Assert
Assert.Equal(2, teams.Length);
Assert.Equal(1, teams[0].Id);
Assert.Equal("/TEST/KING-STEPHEN", teams[0].ApiDetailUrl);
Assert.Equal(2, teams[1].Id);
Assert.Equal("/TEST/NIVEN-LARRY", teams[1].ApiDetailUrl);
}
public void Verify_Remove_Should_RemoveTheEntityFromTheContext()
{
// Arrange
Mock<IDbSet<Team>> mockSetTeams;
var mockContext = TeamsMockingSetup.DoMockingSetupForContext(true, out mockSetTeams);
var repository = new TeamsRepository(mockContext.Object);
var teams = repository.Get(1);
// Act
repository.Remove(teams);
// Assert
mockSetTeams.Verify(x => x.Remove((Team)teams), Times.Once);
}
