private List <SportViewModel> GetAllSportOfPlace(Place place)
{
List <SportViewModel> sportList = new List <SportViewModel>();
List <Field> fieldList = place.Fields.ToList();
foreach (var field in fieldList)
{
SportViewModel sport = Mapper.Map <SportViewModel>(field.FieldType.Sport);
if (sportList.Count == 0)
{
sportList.Add(sport);
}
else
{
for (int i = 0; i < sportList.Count; i++)
{
var s = sportList[i];
if (s.Id != sport.Id)
{
sportList.Add(sport);
}
}
}
}
return(sportList);
}
public async Task <IActionResult> Create(SportViewModel sportViewModel)
{
if (ModelState.IsValid)
{
string path = string.Empty;
if (sportViewModel.LogoFile != null)
{
path = await _imageHelper.UploadImageAsync(sportViewModel.LogoFile, "Sports");
}
SportEntity sportEntity = _converterHelper.ToSportEntity(sportViewModel, path, true);
_context.Add(sportEntity);
try
{
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
if (ex.InnerException.Message.Contains("duplicate"))
{
ModelState.AddModelError(string.Empty, $"Already exists the sport: {sportEntity.Name}");
}
else
{
ModelState.AddModelError(string.Empty, ex.InnerException.Message);
}
}
}
return(View(sportViewModel));
}
public async Task UpdateAsync(SportViewModel model)
{
var dbSport = await _repo.Sports.GetByIdAsync(model.Id);
if (model.IconBlobName != dbSport.IconBlobName)
{
//delete current one
new AzureStorage(dbSport.IconContainer, true).DeleteFile(dbSport.IconBlobName);
}
if (model.IsActive == false)
{
var teams = await _repo.Teams.Where(m => m.SportId == model.Id && m.DateDeletedUtc == null).ToListAsync();
foreach (var team in teams)
{
team.IsActive = false;
}
var feeds = await _repo.RssFeeds.Where(m => m.SportId == model.Id && m.DateDeletedUtc == null).ToListAsync();
foreach (var feed in feeds)
{
feed.IsActive = false;
}
}
await _repo.SaveAsync();
await _repo.Sports.AddOrUpdateAndSaveAsync(MapAddUpdate(true).CreateMapper().Map(model, dbSport));
}
public SportEntity ToSportEntity(SportViewModel model, string path, bool isNew)
{
return(new SportEntity
{
Id = isNew ? 0 : model.Id,
LogoPath = path,
Name = model.Name
});
}
public ActionResult newSport()
{
var sportLista = _context.Sportagak.ToList();
SportViewModel model = new SportViewModel();
model.sportagLista = sportLista;
return(View(model));
}
public ViewResult ArchiveSport()
{
ViewBag.Title = "Archief sport";
var model = new SportViewModel {
Sports = _sportAccess.GetArchivedSports()
};
return(View(model));
}
public SportViewModel Sport_information(string name)
{
using (var ctx = new Context())
{
SportViewModel sport = new SportViewModel();
sport.Sport = ctx.Sports.Include("User").Single(s => s.Name == name);
sport.ActualComment = ctx.Sport_comments.Single(s => s.Sport.ID == sport.Sport.ID && s.Active == true).Comment;
return(sport);
}
}
public async Task <ActionResult> Edit([Bind(Include = "SportItemId,SportItemName,SportItemPrice,SportItemDescription")] SportViewModel sport)
{
if (ModelState.IsValid)
{
await Service.UpdateAsync(AutoMapper.Mapper.Map <ISport>(sport));
return(RedirectToAction("Index"));
}
return(View(sport));
}
public async Task <IHttpActionResult> Post(SportViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _sportsBuilder.AddAsync(model);
return(Ok());
}
public async Task <ActionResult> EditSport(SportViewModel sportModel)
{
_sportService.EditSport(new DomainClasses.Sport
{
Id = sportModel.Id,
Name = sportModel.Name
});
await _dbContext.SaveChangesAsync();
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
public ActionResult Update(SportViewModel model)
{
if (ModelState.IsValid)
{
var sportDb = this.Mapper.Map<Sport>(model);
this.sports.Update(sportDb);
this.sports.SaveChanges();
this.HttpContext.Cache.Remove("menu");
}
return RedirectToAction("Index");
}
public List <SportViewModel> Sport_list()
{
using (var ctx = new Context())
{
List <SportViewModel> list = new List <SportViewModel>();
IEnumerable <Sport> sports = ctx.Sports.ToList();
foreach (var sport in sports)
{
var jedan = new SportViewModel();
jedan.Sport = ctx.Sports.Include("User").Single(s => s.Name == sport.Name);
jedan.ActualComment = ctx.Sport_comments.Single(s => s.Sport.ID == sport.ID && s.Active == true).Comment;
list.Add(jedan);
}
return(list);
}
}
public ActionResult Edit(int id)
{
if (id == 0)
{
return(HttpNotFound());
}
var letezoSport = _context.Sportok.Single(u => u.Id == id);
var sportLista = _context.Sportagak.ToList();
var vm = new SportViewModel()
{
Sport = letezoSport,
sportagLista = sportLista
};
return(View("newSport", vm));
}
public ActionResult Detail(int id)
{
var model = new SportViewModel();
var service = this.Service <ISportService>();
var sport = service.Get(id);
if (sport == null)
{
return(this.IdNotFound());
}
else
{
model = Mapper.Map <SportViewModel>(sport);
//model.
}
return(this.PartialView(model));
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
SportEntity sportEntity = await _context.Sports.FindAsync(id);
if (sportEntity == null)
{
return(NotFound());
}
SportViewModel sportViewModel = _converterHelper.ToSportViewModel(sportEntity);
return(View(sportViewModel));
}
public ActionResult Update(SportViewModel model)
{
var result = new AjaxOperationResult();
try
{
var service = this.Service <ISportService>();
Sport sport = service.Get(model.Id);
sport.Name = model.Name;
sport.Description = model.Description;
service.Update(sport);
service.Save();
result.Succeed = true;
}
catch (Exception e)
{
result.Succeed = false;
}
return(Json(result));
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
SportModel = NavigationServices.CurrentViewModel as SportViewModel;
if (e.NavigationMode == NavigationMode.New && NavigationContext.QueryString.ContainsKey("id"))
{
string id = NavigationContext.QueryString["id"];
if (!String.IsNullOrEmpty(id))
{
_isDeepLink = true;
SportModel = new SportViewModel();
NavigationServices.CurrentViewModel = SportModel;
SportModel.LoadItem(id);
}
}
if (SportModel != null)
{
SportModel.ViewType = ViewTypes.Detail;
}
DataContext = SportModel;
base.OnNavigatedTo(e);
}
public async Task AddAsync(SportViewModel model)
{
await _repo.Sports.AddOrUpdateAndSaveAsync(MapAddUpdate(false).CreateMapper().Map <Sport>(model));
}
public SportPage()
{
InitializeComponent();
SportModel = new SportViewModel();
this.Loaded += SportPage_Loaded;
}
public IActionResult RestoreSport(SportViewModel viewModel)
{
_sportAccess.RestoreSport(viewModel.SelectedSportId);
return(RedirectToAction("ArchiveSport"));
}
