public ActionResult Edit(string id)
{
SeasonViewModel model = new SeasonViewModel();
try
{
if (ModelState.IsValid)
{
var seasonId = Convert.ToInt32(id);
var checkSeason = _dbContext.tbl_Seasons.Where(w => w.Id == seasonId).FirstOrDefault();
if (checkSeason != null)
{
model.Id = checkSeason.Id;
model.Name = checkSeason.Name;
model.StartDay = checkSeason.StartDay;
model.EndDay = checkSeason.EndDay;
}
else
{
return(RedirectToAction("List", "Season"));
}
}
}
catch (Exception ex)
{
}
return(View(model));
}
public ActionResult Edit(SeasonViewModel model)
{
try
{
if (ModelState.IsValid)
{
var checkSeason = _dbContext.tbl_Seasons.Where(w => w.Name == model.Name && w.Id != model.Id).FirstOrDefault();
if (checkSeason == null)
{
var userDetail = _dbContext.tbl_Seasons.Where(w => w.Id == model.Id).FirstOrDefault();
userDetail.Name = model.Name;
userDetail.StartDay = model.StartDay;
userDetail.EndDay = model.EndDay;
userDetail.ModifiedBy = UserId;
userDetail.ModifiedDate = DateTime.Now;
_dbContext.SaveChanges();
ViewBag.SuccessMessage = "Season updated successfully";
}
else
{
ViewBag.ErrorMessage = "Season name is already exists";
}
}
}
catch (Exception ex)
{
}
return(View(model));
}
public async Task <IActionResult> Edit(SeasonViewModel seasonViewModel)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError(string.Empty, "Data is not valid");
seasonViewModel.ChampionshipsItems = championshipService.GetAllAsKeyValuePairs();
return(View(seasonViewModel));
}
try
{
await seasonService.UpdateAsync(seasonViewModel);
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.InnerException?.Message ?? ex.Message);
seasonViewModel.ChampionshipsItems = championshipService.GetAllAsKeyValuePairs();
return(View(seasonViewModel));
}
TempData["SuccessMessage"] = $"Season {seasonViewModel.Name} updated successfully.";
return(RedirectToAction("Index"));
}
protected override void Handle(SeasonCreatedEvent notification)
{
var seasonVM = new SeasonViewModel(notification.SeasonId);
this.context.Seasons.AddAsync(seasonVM);
this.context.SaveChangesAsync();
}
public IActionResult GetAllRoomRatesBySeason(long id)
{
var season = _seasonRepository.GetSeasonById(id);
var roomRates = _roomRateRepository.GetAllRoomRatesBySeasonId(season.Id);
var roomRatesBySeasonOutputModel = new List <RoomRateViewModel>();
foreach (var rate in roomRates)
{
roomRatesBySeasonOutputModel.Add(new RoomRateViewModel()
{
RateId = rate.Id,
RoomType = rate.Room.Type,
SeasonType = rate.Season.Type,
Rate = rate.Price,
From = rate.Season.StartingDate,
To = rate.Season.EndingDate
});
}
SeasonViewModel seasonOutputModel = new SeasonViewModel()
{
Id = season.Id,
SeasonType = season.Type,
StartingDate = season.StartingDate,
EndingDate = season.EndingDate
};
ViewBag.Season = season;
return(View("RoomRates", roomRatesBySeasonOutputModel));
}
public async Task <HttpResponseMessage> Get(int id)
{
Season season = await this.seasonRepository.Get(id);
if (season == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
else
{
SeasonViewModel sVM = new SeasonViewModel();
sVM.Id = season.Id;
sVM.Name = season.Name;
List <LeagueViewModel> leagueViewModel = new List <LeagueViewModel>();
// Get all the leagues attached to the season
LeagueFilter lf = new LeagueFilter();
lf.SeasonId = season.Id;
IEnumerable <League> leagues = await this.leagueRepository.GetAllWithFilter(lf);
if (leagues != null)
{
foreach (League league in leagues)
{
leagueViewModel.Add(await this.leagueRepository.GetViewModel(league.Id));
}
}
sVM.LeagueViewModels = leagueViewModel;
return(Request.CreateResponse(HttpStatusCode.OK, sVM));
}
}
public async Task UpdateAsync(SeasonViewModel seasonViewModel)
{
var allSeasons = seasonRepository.All();
var season = allSeasons.FirstOrDefault(c => c.Id == seasonViewModel.Id);
if (season is null)
{
throw new Exception($"Season not found");
}
var doesSeasonExist = allSeasons.Any(c =>
c.Id != seasonViewModel.Id &&
c.Name == seasonViewModel.Name &&
c.Championship.Id == seasonViewModel.ChampionshipId);
if (doesSeasonExist)
{
throw new Exception($"Season with a name {seasonViewModel.Name} already exists.");
}
season.Name = seasonViewModel.Name;
season.Description = seasonViewModel.Description;
season.Championship = championshipRepository.Get(seasonViewModel.ChampionshipId);
await seasonRepository.SaveChangesAsync();
}
public async Task UpdateNotExistingSeason()
{
var championshipsList = new List <Championship> {
new Championship {
Id = 1, Name = "Premier League"
}
};
var seasonsList = new List <Season>();
var mockChampionshipRepo = new Mock <IRepository <Championship> >();
var mockSeasonRepo = new Mock <IRepository <Season> >();
mockSeasonRepo.Setup(r => r.All()).Returns(seasonsList.AsQueryable());
var seasonService = new SeasonService(mockSeasonRepo.Object, mockChampionshipRepo.Object);
var updatedViewModel = new SeasonViewModel
{
Id = 1,
Name = "2015/16",
ChampionshipId = 1
};
await Assert.ThrowsAsync <Exception>(() => seasonService.UpdateAsync(updatedViewModel));
}
public async Task <IActionResult> Edit(int lastSerieID, SeasonViewModel model)
{
string uniqueFileName = null;
if (ModelState.IsValid)
{
if (model.Photo != null)
{
string UploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "images");
uniqueFileName = GetUniqueFilmName(model.Photo.FileName);
string filePath = Path.Combine(UploadsFolder, uniqueFileName);
model.Photo.CopyTo(new FileStream(filePath, FileMode.Create));
}
var season = _context.Seasons.Find(model.ID);
season.Titel = model.Titel;
season.Nr = model.Nr;
season.SerieID = model.SerieID;
season.Rating = model.Rating;
season.YoutubeTrailer = model.YoutubeTrailer;
if (model.Photo != null)
{
season.PhotoPath = uniqueFileName;
}
_context.Update(season);
await _context.SaveChangesAsync();
}
return(RedirectToAction(nameof(Index)));
}
public ActionResult <object> Post([FromBody] SeasonViewModel user)
{
if (user == null)
{
var toSerialize = new MessageHelpers <SeasonViewModel>()
{
Status = 404,
Data = null
};
return(JsonConvert.SerializeObject(toSerialize));
}
else
{
try
{
var id = _seasonServiceAsync.Add(user);
var toSerialize = new MessageHelpers <SeasonViewModel>()
{
Status = 200,
Data = null
};
return(JsonConvert.SerializeObject(toSerialize));
}
catch
{
var toSerialize = new MessageHelpers <SeasonViewModel>()
{
Status = 502,
Data = null
};
return(JsonConvert.SerializeObject(toSerialize));
}
}
}
public void Create(SeasonViewModel model, HttpPostedFileBase[] photos)
{
var seasonToAdd = new Season();
seasonToAdd.Title = model.Title;
seasonToAdd.Description = model.Description;
seasonToAdd.Year = model.Year;
seasonToAdd.DateCreated = DateTime.Now;
_db.Seasons.Add(seasonToAdd);
_db.SaveChanges();
foreach (var file in photos)
{
var fileName = Guid.NewGuid().ToString();
var extension = Path.GetExtension(file.FileName);
var path = Path.Combine(HttpContext.Current.Server.MapPath("~/Content/assets/img"), fileName + extension);
var photoToAdd = new Photo();
photoToAdd.SeasonId = seasonToAdd.Id;
photoToAdd.Name = fileName;
photoToAdd.Extension = extension;
photoToAdd.Path = path;
file.SaveAs(path);
_db.Photos.Add(photoToAdd);
_db.SaveChanges();
}
}
public ActionResult Add(SeasonViewModel model)
{
try
{
if (ModelState.IsValid)
{
var checkRole = _dbContext.tbl_Seasons.Where(w => w.Name == model.Name).FirstOrDefault();
if (checkRole == null)
{
Season season = new Season()
{
Name = model.Name,
StartDay = model.StartDay,
EndDay = model.EndDay,
IsActive = true,
CreatedBy = UserId,
CreatedDate = DateTime.Now
};
_dbContext.tbl_Seasons.Add(season);
_dbContext.SaveChanges();
ViewBag.SuccessMessage = "Season added successfully";
}
else
{
ViewBag.ErrorMessage = "Season name is already exists";
}
}
}
catch (Exception ex)
{
}
return(View(model));
}
public void Edit(SeasonViewModel model, HttpPostedFileBase[] photos)
{
var seasonToEdit = _db.Seasons.FirstOrDefault(x => x.Id == model.Id);
seasonToEdit.Title = model.Title;
seasonToEdit.Description = model.Description;
seasonToEdit.Year = model.Year;
_db.SaveChanges();
if (photos[0] != null)
{
foreach (var file in photos)
{
var fileName = Guid.NewGuid().ToString();
var extension = Path.GetExtension(file.FileName);
var path = Path.Combine(HttpContext.Current.Server.MapPath("~/Content/assets/img"), fileName + extension);
var photoToAdd = new Photo();
photoToAdd.SeasonId = seasonToEdit.Id;
photoToAdd.Name = fileName;
photoToAdd.Extension = extension;
photoToAdd.Path = path;
file.SaveAs(path);
_db.Photos.Add(photoToAdd);
_db.SaveChanges();
}
}
}
public SeasonPage(Season season)
{
InitializeComponent();
this.season = season;
BindingContext = viewModel = new SeasonViewModel(UserDialogs.Instance, season);
}
public SeasonPage(int mtvsId)
{
InitializeComponent();
BindingContext = model = new SeasonViewModel
{
MTVSId = mtvsId
};
}
public void Update(SeasonViewModel vm)
{
Season p = new Season();
p.Id = vm.Id;
p.Name = vm.Name;
_context.Seasons.Update(p);
_context.SaveChanges();
}
public IActionResult Create()
{
var seasonViewModel = new SeasonViewModel
{
ChampionshipsItems = championshipService.GetAllAsKeyValuePairs()
};
return(View(seasonViewModel));
}
public SeasonViewModelTests()
{
_viewModelFactory = Substitute.For<ITvShowViewModelFactory>();
_tvShowFileService = Substitute.For<ITvShowFileService>();
_tvShowMetadata = Substitute.For<ITvShowViewModel>();
_busyProvider = _busyProvider = Substitute.For<IBusyProvider>();
_path = @"C:\Folder\TV Shows\Game of Thrones\Season 1";
_viewModel = new SeasonViewModel(_viewModelFactory, _tvShowFileService, _tvShowMetadata, null, _busyProvider, _path);
}
public ActionResult Edit(SeasonViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
DP.Edit(model, model.Upload);
return(RedirectToAction("Seasons", "Admin"));
}
public void Create(SeasonViewModel seasonVM)
{
var Season = new Season
{
SeasonName = seasonVM.SeasonName
};
unitOfWork.SeasonRepository.Insert(Season);
unitOfWork.Save();
}
public int Add(SeasonViewModel vm)
{
var p = new Season();
p.Name = vm.Name;
var a = _context.Seasons.Add(p);
_context.SaveChanges();
return(a.Entity.Id);
}
public void Update(SeasonViewModel seasonVM)
{
var Season = new Season
{
SeasonId = seasonVM.SeasonId,
SeasonName = seasonVM.SeasonName
};
unitOfWork.SeasonRepository.Update(Season);
unitOfWork.Save();
}
public IHttpActionResult GetSeason(int id)
{
if (!_brokenShoeLeagueRepository.SeasonExist(id))
{
return(NotFound());
}
var response = new SeasonViewModel(_brokenShoeLeagueRepository.GetSeasonById(id));
return(Ok(response));
}
public virtual ActionResult Edit(SeasonViewModel model)
{
if (ModelState.IsValid)
{
var season = _seasonService.GetById(model.SeasonId);
season.Years = model.Years;
_seasonService.Update(season);
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task SaveAndUpdateSeasonWithNameOfAnotherdExistingSeason()
{
var championshipsList = new List <Championship> {
new Championship {
Id = 1, Name = "Premier League"
}
};
var seasonsList = new List <Season>();
var id = 1;
var mockChampionshipRepo = new Mock <IRepository <Championship> >();
mockChampionshipRepo.Setup(r => r.Get(It.IsAny <int>())).Returns <int>(id => championshipsList.FirstOrDefault(c => c.Id == id));
var mockSeasonRepo = new Mock <IRepository <Season> >();
mockSeasonRepo.Setup(r => r.All()).Returns(seasonsList.AsQueryable());
mockSeasonRepo.Setup(r => r.AddAsync(It.IsAny <Season>())).Callback <Season>(season => seasonsList.Add(new Season
{
Id = id++,
Name = season.Name,
Championship = season.Championship
}));
var seasonService = new SeasonService(mockSeasonRepo.Object, mockChampionshipRepo.Object);
var firstSeasonViewModel = new SeasonViewModel
{
Name = "2020/21",
ChampionshipId = 1
};
var secondSeasonViewModel = new SeasonViewModel
{
Name = "2019/20",
ChampionshipId = 1
};
await seasonService.CreateAsync(firstSeasonViewModel);
await seasonService.CreateAsync(secondSeasonViewModel);
var secondUpdatedViewModel = new SeasonViewModel
{
Id = 2,
Name = "2020/21",
ChampionshipId = 1
};
await Assert.ThrowsAsync <Exception>(() => seasonService.UpdateAsync(secondUpdatedViewModel));
}
public async Task <List <SeasonViewModel> > GetAll()
{
var listItems = await _context.Seasons.ToListAsync();
List <SeasonViewModel> listVM = new List <SeasonViewModel>();
foreach (var item in listItems)
{
SeasonViewModel vm = new SeasonViewModel();
vm.Id = item.Id;
vm.Name = item.Name;
listVM.Add(vm);
}
return(listVM);
}
public ActionResult Edit(int id)
{
var seasonToEdit = DP.GetSeasonById(id);
var viewModel = new SeasonViewModel()
{
Id = seasonToEdit.Id,
Title = seasonToEdit.Title,
Description = seasonToEdit.Description,
Year = seasonToEdit.Year
};
ViewBag.Imgs = seasonToEdit.Photos.Where(x => x.SeasonId == id);
return(View(viewModel));
}
public IActionResult Edit(int id)
{
var season = seasonService.Get(id);
var seasonViewModel = new SeasonViewModel
{
Id = id,
Name = season.Name,
Description = season.Description,
ChampionshipId = season.Championship.Id,
ChampionshipName = season.Championship.Name,
ChampionshipsItems = championshipService.GetAllAsKeyValuePairs()
};
return(View(seasonViewModel));
}
// GET: Season/Details/5
public ActionResult Details(int id = 0)
{
if (id == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SeasonViewModel details = seasonService.GetById(id);
if (details == null)
{
return(HttpNotFound());
}
return(View(details));
}
public IActionResult Delete(int id)
{
var season = seasonService.Get(id);
var seasonViewModel = new SeasonViewModel
{
Id = id,
Name = season.Name,
Description = season.Description,
ChampionshipId = season.Championship.Id,
ChampionshipName = season.Championship.Name,
};
ViewData["EntityName"] = "Season";
return(View("../Shared/_Delete", seasonViewModel));
}
//create season
public IHttpActionResult Post([FromBody] SeasonViewModel season)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_brokenShoeLeagueRepository.CreateSeason(new Season
{
Name = season.Name,
StartDate = season.StartDate
});
_brokenShoeLeagueRepository.SaveChanges();
return(Ok(season));
}
