public async Task Returns_CompetitionsViewModel_from_builder()
{
var model = new CompetitionsViewModel(Mock.Of <IPublishedContent>(), Mock.Of <IUserService>())
{
Filter = new CompetitionFilter()
};
var dataSource = new Mock <ICompetitionDataSource>();
var listingsBuilder = new Mock <IListingsModelBuilder <Competition, CompetitionFilter, CompetitionsViewModel> >();
listingsBuilder.Setup(x => x.BuildModel(
It.IsAny <Func <CompetitionsViewModel> >(),
dataSource.Object.ReadTotalCompetitions,
dataSource.Object.ReadCompetitions,
Constants.Pages.Competitions,
_pageUrl,
_queryString
)).Returns(Task.FromResult(model));
using (var controller = CreateController(dataSource.Object, listingsBuilder.Object))
{
var result = await controller.Index(new ContentModel(Mock.Of <IPublishedContent>())).ConfigureAwait(false);
listingsBuilder.Verify(x => x.BuildModel(
It.IsAny <Func <CompetitionsViewModel> >(),
dataSource.Object.ReadTotalCompetitions,
dataSource.Object.ReadCompetitions,
Constants.Pages.Competitions,
_pageUrl,
_queryString
), Times.Once);
Assert.Equal(model, ((ViewResult)result).Model);
}
}
public CompetitiveEventsPage()
{
InitializeComponent();
this.BindingContext = viewModel = new CompetitionsViewModel();
CompetitionsListView.ItemSelected += CompetitionsListView_ItemSelected;
}
public async void TestCreate()
{
//Arrange
var c = new Competition
{
Id = 1,
Name = "Vorhlaup",
Description = "Um vorhlaupid",
Email = "*****@*****.**",
Phone = "5551234",
Sponsor = "",
WebPage = "vorhlaup.is"
};
var cMod = new CompetitionsViewModel
{
Name = "Vorhlaup",
Description = "Um vorhlaupid",
Email = "*****@*****.**",
PhoneNumber = "5551234",
Sponsor = "",
WebPage = "vorhlaup.is"
};
var serviceMock = new Mock <ICompetitionService>();
serviceMock.Setup(x => x.AddAsync(cMod)).Returns(Task.FromResult(c));
var controller = new CompetitionController(serviceMock.Object);
//Act
var result = await controller.Create(cMod) as RedirectToActionResult;
//Assert
Assert.Equal(expected: "Competitions", actual: result.ActionName);
}
public MainPage()
{
InitializeComponent();
_todaysGames = GetDataFromGames(DateTime.Now, false);
_todaysGames.FillCountryNames();
BindingContext = new CompetitionsViewModel(_todaysGames.competitions);
}
public CompetitionsPage()
{
InitializeComponent();
_vm = new CompetitionsViewModel();
BindingContext = _vm;
Title = "ZAWODY";
grid.IsVisible = true;
LblNoInternet.IsVisible = false;
}
public IActionResult ControlPanel(CompetitionsViewModel model)
{
int round = competitionRepo.GetRoundNumberFromRaceID(model.CompetitionID);
api.GetRaceResultsFromApi(round);
CompetitionsViewModel vm = new CompetitionsViewModel();
vm.Competitions = competitionRepo.GetCompetitions();
return(View(vm));
}
/// <summary>
/// Function to edit a competition
/// </summary>
/// <param name="c"></param>
/// <param name="m"></param>
/// <returns>Edited competition</returns>
public async Task <Competition> EditAsync(Competition c, CompetitionsViewModel m)
{
c.Description = m.Description;
c.Email = m.Email;
c.Name = m.Name;
c.Phone = m.PhoneNumber;
c.Sponsor = m.Sponsor;
c.WebPage = m.WebPage;
await _repo.EditAsync(c);
return(c);
}
public ActionResult Admin()
{
List <Competitions> comps = unitOfWork.CompetitionRepository.Get(includeProperties: "Groups").ToList();
comps.Reverse();
var model = new CompetitionsViewModel()
{
Competitions = comps
};
return(View(model));
}
public IActionResult ControlPanel()
{
string user = HttpContext.Session.GetString("Account");
if (user != null)
{
User u = userRepo.GetUser(HttpContext.Session.GetString("Account"));
if (u.Admin == true)
{
CompetitionsViewModel vm = new CompetitionsViewModel();
vm.Competitions = competitionRepo.GetCompetitions();
return(View(vm));
}
}
return(NotFound());
}
public async Task <IActionResult> Edit(int competitionId, CompetitionsViewModel model)
{
if (competitionId != model.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var competition = await _competitionService.GetCompetitionByIdAsync(model.Id);
await _competitionService.EditAsync(competition, model);
return(RedirectToAction("Competitions", "Admin"));
}
return(View(model));
}
public async Task <IActionResult> Create(CompetitionsViewModel model)
{
if (ModelState.IsValid && model.Name != null)
{
var exists = await _competitionService.CompetitionExistsAsync(model.Name);
if (!exists)
{
await _competitionService.AddAsync(model);
return(RedirectToAction("Competitions", "Admin"));
}
return(Json("Competition with this name already exists"));
}
return(View(model));
}
public async Task <IViewComponentResult> InvokeAsync(int meetingId)
{
var request = new HttpRequestMessage(HttpMethod.Get, $"http://api-rideklub.scriptbear.dk/api/equipe/GetCompetitions/{meetingId}");
var competitions = await HttpTool.SendRequest <IEnumerable <Competition> >(request);
if (competitions == null)
{
return(View("Partials/Equipe/Competitions.cshtml", new CompetitionsViewModel()));
}
var equipeModel = new CompetitionsViewModel
{
Competitions = competitions,
MeetingId = meetingId
};
return(View("Partials/Equipe/Competitions.cshtml", equipeModel));
}
/// <summary>
/// Function to add new competition.
/// </summary>
/// <param name="c">CompetitionViewModel</param>
/// <returns>Returns the newly created competition</returns>
public async Task <Competition> AddAsync(CompetitionsViewModel c)
{
//TODO: Check if competition exists
var newComp = new Competition
{
Name = c.Name,
WebPage = c.WebPage,
Email = c.Email,
Phone = c.PhoneNumber,
Description = c.Description,
Sponsor = c.Sponsor,
Deleted = false
};
await _repo.InsertAsync(newComp);
return(newComp);
}
public void CompetionsViewIsUpdated()
{
CompetitionsViewModel competitonsView = new CompetitionsViewModel();
DownloadCompetitions downresults = new DownloadCompetitions();
ListView lst = new ListView();
Grid grd = new Grid();
Label lbl = new Label();
competitonsView.DownloadData(downresults, lst, grd, lbl);
List <CustomCompetition> cstlst = (List <CustomCompetition>)lst.ItemsSource;
Assert.AreEqual(cstlst[0].Id, downresults.results[0].Id);
Assert.AreEqual(cstlst[0].Caption, downresults.results[0].Caption);
Assert.AreEqual(cstlst[0].League, downresults.results[0].League);
Assert.AreEqual(cstlst[0].CurrentMatchday, downresults.results[0].CurrentMatchday.ToString());
Assert.AreEqual(cstlst[0].NumberOfMatchdays, downresults.results[0].NumberOfMatchdays.ToString());
Assert.AreEqual(cstlst[0].NumerOfTeams, downresults.results[0].NumberOfTeams.ToString());
}
//
// GET: /Discgolftouren/
public ActionResult Index()
{
var vm = new CompetitionsViewModel();
var competitions = new List <Competition>();
using (var session = NHibernateFactory.OpenSession())
{
competitions = session.Query <Competition>().Where(c => c.Date.Year == DateTime.Now.Year).OrderBy(c => c.Date).ToList();
}
foreach (var competition in competitions)
{
var cp = new CompetitionDTO()
{
Id = competition.Id,
Name = competition.Name,
Date = competition.Date
};
vm.Competitions.Add(cp);
}
return(View(vm));
}
public ActionResult Tournament(CompetitionsViewModel vm, int id = -1)
{
vm.YearsList = new List <SelectListItem>();
AddYear(vm.YearsList, "2015", vm.SelectedYear);
AddYear(vm.YearsList, "2016", vm.SelectedYear);
if (id != -1)
{
// hämta data för tävling
using (var session = NHibernateFactory.OpenSession())
{
var competition = session.Get <Competition>(id);
if (competition != null)
{
vm.Competition = new CompetitionDTO()
{
Id = competition.Id,
Name = competition.Name,
Date = competition.Date,
PGDAWebPage = competition.PdgaWebPage,
Description = competition.Description
};
var players = session.Query <PlayerStatus>().Where(p => p.Competition.Id == competition.Id);
foreach (var player in players.Where(p => p.Status == NHibernate.Enums.PlayerCompetitionStatus.Payed))
{
vm.Competition.Players.Add(new PlayerDTO()
{
Namn = string.Format("{0} {1}", player.Player.FirstName, player.Player.LastName),
PDGA = player.Player.PdgaNumber,
Rating = player.Player.Rating
});
}
foreach (var player in players.Where(p => p.Status == NHibernate.Enums.PlayerCompetitionStatus.Registered))
{
vm.Competition.RegisteredPlayers.Add(new PlayerDTO()
{
Namn = string.Format("{0} {1}", player.Player.FirstName, player.Player.LastName),
PDGA = player.Player.PdgaNumber,
Rating = player.Player.Rating
});
}
foreach (var player in players.Where(p => p.Status == NHibernate.Enums.PlayerCompetitionStatus.Waiting))
{
vm.Competition.WaitingPlayers.Add(new PlayerDTO()
{
Namn = string.Format("{0} {1}", player.Player.FirstName, player.Player.LastName),
PDGA = player.Player.PdgaNumber,
Rating = player.Player.Rating
});
}
}
}
}
else
{
// hämta data för tävlingar
var competitions = new List <Competition>();
using (var session = NHibernateFactory.OpenSession())
{
competitions = session.Query <Competition>().Where(c => c.Date.Year == int.Parse(vm.SelectedYear)).OrderBy(c => c.Date).ToList();
}
foreach (var competition in competitions)
{
var cp = new CompetitionDTO()
{
Id = competition.Id,
Name = competition.Name,
Date = competition.Date,
};
vm.Competitions.Add(cp);
}
}
return(View(vm));
}
