public Regatta Remove(Regatta regatta)
{
var removedRegatta = _regattaContext.Regattas.Remove(regatta);
_regattaContext.SaveChanges();
return(removedRegatta);
}
public RegattaServiceTests()
{
_context = Utilities.InMemoryContextBuilder.GetContext();
_clubInitials = _context.Clubs.First().Initials;
_clubId = _context.Clubs.First().Id;
_regatta = _context.Regattas.First();
_mockSeriesService = new Mock <ISeriesService>();
var config = new MapperConfiguration(opts =>
{
opts.AddProfile(new DbToModelMappingProfile());
});
_mapper = config.CreateMapper();
//yep, this means we are testing the real DbObjectBuilder as well:
_dbObjectBuilder = new DbObjectBuilder(
_context,
_mapper
);
_service = new RegattaService(
_mockSeriesService.Object,
_context,
_dbObjectBuilder,
_mapper
);
}
public ActionResult Create(CreateRegattaViewModel createRegattaViewModel)
{
if (ModelState.IsValid)
{
AddressContact addressContact = CreateAddressContact(createRegattaViewModel);
ContactPerson contactPerson = CreateContactPerson(createRegattaViewModel);
Mapper.Initialize(cfg => cfg.CreateMap <PocoClasses.Regattas.Regatta, Regatta>());
Regatta regatta = Mapper.Map <Regatta>(createRegattaViewModel.Regatta);
regatta.AddressContactId = addressContact.Id;
regatta.ContactPersonsId = contactPerson.Id;
regatta.HostingClubId = FindClubId();
using (var context = new RegattaContext())
{
var service = new RegattaService(context);
service.Add(regatta);
}
ViewBag.AddressContactId = new SelectList(new AddressContactContext().AddressContacts, "Id", "NextOfKin", regatta.AddressContactId);
// ViewBag.AddressContactId = new SelectList(new AddressContactService(new AddressContactContext()).GetAll(),"Id","NextOfKin",regatta.AddressContactId);
// ViewBag.HostingClubId = new SelectList(new ClubService(new ClubContext()).GetAll(), "Id", "Name", regatta.HostingClubId);
// ViewBag.ContactPersonsId = new SelectList(new ContactPersonService(new ContactPersonContext()).GetAll(), "Id", "Email", regatta.ContactPersonsId);
return(RedirectToAction("Index"));
}
return(View(createRegattaViewModel));
}
public Regatta Add(Regatta regatta)
{
var returnedRegatta = _regattaContext.Regattas.Add(regatta);
_regattaContext.Context.SaveChanges();
return(returnedRegatta);
}
public async Task <int> CreateRegatta(Regatta regatta)
{
_context.Regattas.Add(regatta);
await _context.SaveChangesAsync();
return(regatta.RegattaId);
}
public ActionResult DeleteConfirmed(int id)
{
Regatta regatta = GetAllRegattas().Find(r => r.Id == id);
new RegattaService(new RegattaContext()).Remove(regatta);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> PutRegatta([FromRoute] int id, [FromBody] Regatta regatta)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != regatta.RegattaId)
{
return(BadRequest());
}
_context.Entry(regatta).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegattaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Edit(Guid id, [Bind("Title,Description,StartTime,EndTime,Address,Id")] Regatta regatta)
{
if (id != regatta.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(regatta);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegattaExists(regatta.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(regatta));
}
private static void CleanupFleets(Regatta model, dbObj.Regatta existingRegatta)
{
var fleetsToRemove = new List <dbObj.RegattaFleet>();
if (model.Fleets != null)
{
fleetsToRemove =
existingRegatta.RegattaFleet
.Where(f => !(model.Fleets.Any(f2 => f2.Id == f.FleetId)))
.ToList();
}
var fleetsToAdd =
model.Fleets != null?
model.Fleets
.Where(c =>
!(existingRegatta.RegattaFleet.Any(f => c.Id == f.FleetId)))
.Select(c => new dbObj.RegattaFleet
{
FleetId = c.Id,
RegattaId = existingRegatta.Id
})
: new List <dbObj.RegattaFleet>();
foreach (var removingFleet in fleetsToRemove)
{
existingRegatta.RegattaFleet.Remove(removingFleet);
}
foreach (var addFleet in fleetsToAdd)
{
existingRegatta.RegattaFleet.Add(addFleet);
}
}
public async Task <IActionResult> Create([Bind("Title,HostingClubId,Description,StartTime,EndTime,Address,Id")] CreateRegattaViewModel regatta)
{
if (ModelState.IsValid)
{
var _currentUser = GetCurrentUser();
var hostClub = await _context.Clubs.SingleOrDefaultAsync(c => c.Id.Equals(regatta.HostingClubId));
var newRegatta = new Regatta
{
Id = Guid.NewGuid(),
CreatedBy = _currentUser,
HostingClub = hostClub,
Title = regatta.Title,
Address = regatta.Address,
Description = regatta.Description,
StartTime = regatta.StartTime,
EndTime = regatta.EndTime
};
_context.Add(newRegatta);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(regatta));
}
public Task <Guid> UpdateAsync(Regatta model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
return(UpdateInternalAsync(model));
}
public Task <Guid> SaveNewRegattaAsync(Regatta regatta)
{
if (regatta == null)
{
throw new ArgumentNullException(nameof(regatta));
}
return(SaveNewRegattaInternalAsync(regatta));
}
public ActionResult Edit(
[Bind(Include = "Id,AddressContactId,ContactPersonId,Name,StartDateTime,EndDateTime,Fee,Description")] Regatta regatta)
{
if (ModelState.IsValid)
{
new RegattaService(new RegattaContext()).Edit(regatta);
return(RedirectToAction("Index"));
}
return(View(regatta));
}
public async Task SaveNewRegattaAsync_NotNull_SaveToDb()
{
var newRegatta = new Regatta
{
Name = "New Regatta"
};
var result = await _service.SaveNewRegattaAsync(
_mapper.Map <SailScores.Core.Model.Regatta>(newRegatta));
Assert.Equal(2, _context.Regattas.Count());
}
public async Task <IActionResult> PostRegatta([FromBody] Regatta regatta)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Regattas.Add(regatta);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetRegatta", new { id = regatta.RegattaId }, regatta));
}
// GET: Regatta/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Regatta regatta = GetAllRegattas().Find(r => r.Id == id);
if (regatta == null)
{
return(HttpNotFound());
}
return(View(regatta));
}
private async Task <dbObj.Season> GetSeasonAsync(Guid clubId, Regatta regatta)
{
dbObj.Season retSeason = null;
if (regatta.Season != null)
{
retSeason = await _dbContext.Seasons
.FirstOrDefaultAsync(s =>
s.ClubId == clubId &&
(s.Id == regatta.Season.Id ||
s.Start == regatta.Season.Start))
.ConfigureAwait(false);
}
if (retSeason == null)
{
retSeason = await GetSeason(clubId, regatta.StartDate, regatta.EndDate, true)
.ConfigureAwait(false);
}
return(retSeason);
}
public async Task BuildDbRegatta_Always_AddsSeries()
{
// arrange
var regatta = new Regatta
{
Series = new List <Series>
{
new Series
{
Name = "regattaSeries"
}
}
};
// act
var result = await _service.BuildDbRegattaAsync(regatta);
// assert
Assert.NotEmpty(result.RegattaSeries);
}
public async Task <IActionResult> RegisterConfirmed(Guid?id, RegattaRegistrationViewModel registration)
{
if (id == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
Regatta regatta = await _context.Regattas
.Include(r => r.Registrations)
.SingleOrDefaultAsync(r => r.Id == id);
var _user = GetCurrentUser();
// Check if there is already a registration for this user
if (regatta.Registrations.Exists(r => r.UserId == _user.Id))
{
// If you have already registered you should be redirected somewhere else.
return(RedirectToAction(nameof(Index)));
}
// Get the boat the user selected from the dropdown
Boat _boat = await _context.Boats.SingleOrDefaultAsync(b => b.Id == registration.SelectedBoatId);
var newRegistration = new RegattaRegistration
{
Regatta = regatta,
Boat = _boat,
User = _user,
Message = registration.Message,
NumberOfParticipants = registration.NumberOfParticipants
};
_context.RegattaRegistration.Add(newRegistration);
_context.SaveChanges();
}
// Create Registration confirmation view!
return(RedirectToAction(nameof(Index)));
}
private async Task <Guid> UpdateInternalAsync(Regatta model)
{
if (_dbContext.Regattas.Any(r =>
r.Id != model.Id &&
r.ClubId == model.ClubId &&
r.Name == model.Name &&
r.Season.Id == model.Season.Id))
{
throw new InvalidOperationException(
"Cannot update Regatta. A regatta with this name in this season already exists.");
}
var existingRegatta = await _dbContext.Regattas
.Include(r => r.RegattaFleet)
.SingleAsync(c => c.Id == model.Id)
.ConfigureAwait(false);
existingRegatta.Name = model.Name;
existingRegatta.Url = model.Url;
existingRegatta.Description = model.Description;
existingRegatta.StartDate = model.StartDate;
existingRegatta.EndDate = model.EndDate;
existingRegatta.UpdatedDate = DateTime.UtcNow;
existingRegatta.ScoringSystemId = model.ScoringSystemId;
existingRegatta.PreferAlternateSailNumbers = model.PreferAlternateSailNumbers;
if (model.Season != null &&
model.Season.Id != Guid.Empty &&
existingRegatta.Season?.Id != model.Season?.Id)
{
existingRegatta.Season = _dbContext.Seasons.Single(s => s.Id == model.Season.Id);
}
CleanupFleets(model, existingRegatta);
await _dbContext.SaveChangesAsync()
.ConfigureAwait(false);
return(existingRegatta.Id);
}
public Regatta Edit(Regatta regatta)
{
var dbRegatta = _regattaContext.Regattas.SingleOrDefault(r => r.Id == regatta.Id);
if (dbRegatta == null)
{
throw new Exception("Can't find regatta in db!");
}
dbRegatta.AddressContactId = regatta.AddressContactId;
dbRegatta.ContactPersonsId = regatta.ContactPersonsId;
dbRegatta.HostingClubId = regatta.HostingClubId;
dbRegatta.Name = regatta.Name;
dbRegatta.StartDateTime = regatta.StartDateTime;
dbRegatta.EndDateTime = regatta.EndDateTime;
dbRegatta.Fee = regatta.Fee;
dbRegatta.Description = regatta.Description;
_regattaContext.SaveChanges();
return(regatta);
}
private async Task <Guid> SaveNewRegattaInternalAsync(Regatta regatta)
{
Database.Entities.Regatta dbRegatta =
await _dbObjectBuilder.BuildDbRegattaAsync(regatta)
.ConfigureAwait(false);
dbRegatta.UrlName = UrlUtility.GetUrlName(dbRegatta.Name);
dbRegatta.UpdatedDate = DateTime.UtcNow;
if (dbRegatta.Season == null &&
regatta.Season.Id != Guid.Empty &&
regatta.Season.Start != default)
{
var season = _mapper.Map <dbObj.Season>(regatta.Season);
_dbContext.Seasons.Add(season);
dbRegatta.Season = season;
}
if (dbRegatta.Season == null)
{
throw new InvalidOperationException(
"Could not find or create season for new Regatta.");
}
if (_dbContext.Regattas.Any(s =>
s.Id == regatta.Id ||
(s.ClubId == regatta.ClubId &&
s.UrlName == regatta.UrlName &&
s.Season.Id == dbRegatta.Season.Id)))
{
throw new InvalidOperationException(
"Cannot create regatta. A regatta with this name in this season already exists.");
}
_dbContext.Regattas.Add(dbRegatta);
await _dbContext.SaveChangesAsync()
.ConfigureAwait(false);
return(dbRegatta.Id);
}
public static ISailScoresContext GetContext()
{
var options = new DbContextOptionsBuilder <SailScoresContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var context = new SailScoresContext(options);
var club = new Club
{
Id = Guid.NewGuid(),
Name = "Test Club",
Initials = "TEST",
Competitors = new List <Competitor>()
};
context.Clubs.Add(club);
var boatClass = new BoatClass
{
Id = Guid.NewGuid(),
Name = "The Boat Class",
ClubId = club.Id
};
context.BoatClasses.Add(boatClass);
var fleet = new Fleet
{
Id = Guid.NewGuid(),
Name = "The Fleet",
FleetType = Api.Enumerations.FleetType.AllBoatsInClub,
ClubId = club.Id
};
context.Fleets.Add(fleet);
var fleet2 = new Fleet
{
Id = Guid.NewGuid(),
Name = "A competitor fleet",
FleetType = Api.Enumerations.FleetType.SelectedBoats,
ClubId = club.Id
};
context.Fleets.Add(fleet2);
var season = new Season
{
Id = Guid.NewGuid(),
Name = "Test Season",
Start = new DateTime(2020, 1, 1),
End = new DateTime(2021, 1, 1),
UrlName = "TestSeason"
};
var competitor = new Competitor
{
Id = Guid.NewGuid(),
Name = "Comp1",
BoatName = "Comp1Boat",
ClubId = club.Id,
BoatClass = boatClass,
CompetitorFleets = new List <CompetitorFleet>
{
new CompetitorFleet
{
FleetId = fleet2.Id
}
}
};
context.Competitors.Add(competitor);
var inactiveCompetitor = new Competitor
{
Id = Guid.NewGuid(),
Name = "Comp12",
BoatName = "Comp12Boat",
ClubId = club.Id,
BoatClass = boatClass,
CompetitorFleets = new List <CompetitorFleet>
{
new CompetitorFleet
{
FleetId = fleet2.Id
}
},
IsActive = false
};
context.Competitors.Add(inactiveCompetitor);
var scoringSystem = new ScoringSystem
{
Id = Guid.NewGuid(),
Name = "Default for fake club",
ClubId = club.Id,
ScoreCodes = new List <ScoreCode>
{
new Database.Entities.ScoreCode
{
Name = "DNC",
CameToStart = false
}
}
};
context.ScoringSystems.Add(scoringSystem);
club.DefaultScoringSystemId = scoringSystem.Id;
var defaultScoringSystem = new ScoringSystem
{
Id = Guid.NewGuid(),
Name = "Appendix A Low Point For Series",
ClubId = null,
IsSiteDefault = true,
ScoreCodes = new List <ScoreCode>
{
new Database.Entities.ScoreCode
{
Name = "DNC",
CameToStart = false
}
}
};
context.ScoringSystems.Add(defaultScoringSystem);
var series = new Series
{
Name = "Series One",
UrlName = "SeriesOne",
ClubId = club.Id,
Season = season
};
context.Series.Add(series);
context.Races.Add(new Race
{
Id = Guid.NewGuid(),
Date = DateTime.Now,
ClubId = club.Id,
Scores = new List <Score>
{
new Score
{
CompetitorId = competitor.Id,
Place = 1
}
},
SeriesRaces = new List <SeriesRace> {
new SeriesRace
{
Series = series
}
}
});
var regattaSeries = new Series
{
Id = Guid.NewGuid(),
Name = "Regatta Series",
UrlName = "RegattaurlName"
};
var regattaFleet = new
Fleet
{
FleetType = Api.Enumerations.FleetType.AllBoatsInClub
};
var regatta = new Regatta
{
ClubId = club.Id,
Season = season,
Name = "Test Regatta",
RegattaFleet = new List <RegattaFleet>
{
new RegattaFleet
{
Fleet = regattaFleet
}
},
StartDate = season.Start.AddMonths(6),
EndDate = season.Start.AddMonths(6).AddDays(3),
RegattaSeries = new List <RegattaSeries>
{
new RegattaSeries
{
Series = regattaSeries
}
}
};
context.Regattas.Add(regatta);
context.SaveChanges();
return(context);
}
public IActionResult Create([Bind("RegattaName,RegattaVon,RegattaBis,Waterdepth,Startslots,ReportText,ReportSchedule,ReportOpening," +
"ReportAddress,ReportTel,ReportFax,ReportMail,Judge,Awards,Security,ScheduleText,SubscriberFee,Accomodation,Comment,Catering,ClubId,WaterId,Organizer,IsApproved")] RegattaVM regattaVM,
IEnumerable <int> schueler, IEnumerable <int> jugend, IEnumerable <int> altersklassen, IEnumerable <int> alleklassen, IEnumerable <int> CompetitionIds, IEnumerable <int> StartingFeeIds, IEnumerable <int> CampingFeeIds)
{
Regatta regatta = new Regatta();
regatta.Name = regattaVM.RegattaName;
regatta.FromDate = regattaVM.RegattaVon;
regatta.ToDate = regattaVM.RegattaBis;
regatta.Waterdepth = regattaVM.Waterdepth;
regatta.Startslots = regattaVM.Startslots;
regatta.ReportText = regattaVM.ReportText;
regatta.ReportSchedule = regattaVM.ReportSchedule;
regatta.ReportOpening = regattaVM.ReportOpening;
regatta.ReportAddress = regattaVM.ReportAddress;
regatta.ReportTel = regattaVM.ReportTel;
regatta.ReportFax = regattaVM.ReportFax;
regatta.ReportMail = regattaVM.ReportMail;
regatta.Judge = regattaVM.Judge;
regatta.Awards = regattaVM.Awards;
regatta.Security = regattaVM.Security;
regatta.ScheduleText = regattaVM.ScheduleText;
regatta.SubscriberFee = regattaVM.SubscriberFee;
regatta.Accomodation = regattaVM.Accomodation;
regatta.Comment = regattaVM.Comment;
regatta.Catering = regattaVM.Catering;
regatta.ClubId = regattaVM.ClubId;
regatta.WaterId = regattaVM.WaterId;
regatta.Organizer = regattaVM.Organizer;
regatta.StartersLastYear = regattaVM.StartersLastYear;
regatta.Category = regattaVM.Category;
regatta.IsApproved = regattaVM.IsApproved;
if (ModelState.IsValid)
{
_context.Add(regatta);
_context.SaveChanges();
foreach (var oc in schueler)
{
_context.RegattaOldclasses.Add(new RegattaOldclass {
RegattaId = regatta.RegattaId, OldclassId = oc
});
}
foreach (var oc in jugend)
{
_context.RegattaOldclasses.Add(new RegattaOldclass {
RegattaId = regatta.RegattaId, OldclassId = oc
});
}
foreach (var oc in altersklassen)
{
_context.RegattaOldclasses.Add(new RegattaOldclass {
RegattaId = regatta.RegattaId, OldclassId = oc
});
}
foreach (var oc in alleklassen)
{
_context.RegattaOldclasses.Add(new RegattaOldclass {
RegattaId = regatta.RegattaId, OldclassId = oc
});
}
foreach (var cf in CampingFeeIds)
{
_context.RegattaCampingFees.Add(new RegattaCampingFee {
RegattaId = regatta.RegattaId, CampingFeeId = cf
});
}
foreach (var rcid in CompetitionIds)
{
_context.RegattaCompetitions.Add(new RegattaCompetition {
RegattaId = regatta.RegattaId, CompetitionId = rcid
});
}
foreach (var rsfid in StartingFeeIds)
{
_context.RegattaStartingFees.Add(new RegattaStartingFee {
RegattaId = regatta.RegattaId, StartingFeeId = rsfid
});
}
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
ViewData["ClubId"] = new SelectList(_context.Clubs, "ClubId", "Name", regatta.ClubId);
ViewData["WaterId"] = new SelectList(_context.Waters, "WaterId", "Name", regatta.WaterId);
ViewData["OldclassIds"] = new MultiSelectList(_context.Oldclasses, "OldclassId", "Name");
ViewData["CompetitionIds"] = new MultiSelectList(_context.Competitions.Include(e => e.Boatclasses).Include(e => e.Raceclasses), "CompetitionId", "Name");
ViewData["StartingFeeIds"] = new MultiSelectList(_context.StartingFees, "StartingFeeId", "Name");
ViewData["CampingFeeIds"] = new MultiSelectList(_context.CampingFees, "CampingFeeId", "LongName");
return(View(regattaVM));
}
public async Task <IActionResult> Edit(int id, [Bind("RegattaId,RegattaName,RegattaVon,RegattaBis,Waterdepth,Startslots,ReportText,ReportSchedule,ReportOpening," +
"ReportAddress,ReportTel,ReportFax,ReportMail,Judge,Awards,Security,ScheduleText,SubscriberFee,Accomodation,Comment,Catering,ClubId,WaterId,Organizer,Category,StartersLastYear,IsApproved")] RegattaVM regattaVM,
IEnumerable <int> OldclassIds, IEnumerable <int> CompetitionIds, IEnumerable <int> StartingFeeIds, IEnumerable <int> CampingFeeIds)
{
if (id != regattaVM.RegattaId)
{
return(NotFound());
}
Regatta regatta = _context.Regattas.FirstOrDefault(e => e.RegattaId == regattaVM.RegattaId);
regatta.Name = regattaVM.RegattaName;
regatta.FromDate = regattaVM.RegattaVon;
regatta.ToDate = regattaVM.RegattaBis;
regatta.Waterdepth = regattaVM.Waterdepth;
regatta.Startslots = regattaVM.Startslots;
regatta.ReportText = regattaVM.ReportText;
regatta.ReportSchedule = regattaVM.ReportSchedule;
regatta.ReportOpening = regattaVM.ReportOpening;
regatta.ReportAddress = regattaVM.ReportAddress;
regatta.ReportTel = regattaVM.ReportTel;
regatta.ReportFax = regattaVM.ReportFax;
regatta.ReportMail = regattaVM.ReportMail;
regatta.Judge = regattaVM.Judge;
regatta.Awards = regattaVM.Awards;
regatta.Security = regattaVM.Security;
regatta.ScheduleText = regattaVM.ScheduleText;
regatta.SubscriberFee = regattaVM.SubscriberFee;
regatta.Accomodation = regattaVM.Accomodation;
regatta.Catering = regattaVM.Catering;
regatta.Comment = regattaVM.Comment;
regatta.ClubId = regattaVM.ClubId;
regatta.WaterId = regattaVM.WaterId;
regatta.Organizer = regattaVM.Organizer;
regatta.StartersLastYear = regattaVM.StartersLastYear;
regatta.Category = regattaVM.Category;
regatta.IsApproved = regattaVM.IsApproved;
IEnumerable <RegattaOldclass> roc = _context.RegattaOldclasses.Where(e => e.RegattaId == regattaVM.RegattaId);
IEnumerable <RegattaCampingFee> rcf = _context.RegattaCampingFees.Where(e => e.RegattaId == regattaVM.RegattaId);
IEnumerable <RegattaCompetition> rc = _context.RegattaCompetitions.Where(e => e.RegattaId == regattaVM.RegattaId);
IEnumerable <RegattaStartingFee> rsf = _context.RegattaStartingFees.Where(e => e.RegattaId == regattaVM.RegattaId);
foreach (var oc in OldclassIds)
{
if (roc.Where(e => e.OldclassId == oc && e.RegattaId == regattaVM.RegattaId).Count() == 0)
{
_context.Regattas.Include(e => e.RegattaOldclasses).FirstOrDefault(m => m.RegattaId == regattaVM.RegattaId).RegattaOldclasses.Add(new RegattaOldclass {
RegattaId = regattaVM.RegattaId, OldclassId = oc
});
}
}
foreach (var cf in CampingFeeIds)
{
if (rcf.Where(e => e.CampingFeeId == cf && e.RegattaId == regattaVM.RegattaId).Count() == 0)
{
_context.Regattas.Include(e => e.RegattaCampingFees).FirstOrDefault(m => m.RegattaId == regattaVM.RegattaId).RegattaCampingFees.Add(new RegattaCampingFee {
RegattaId = regattaVM.RegattaId, CampingFeeId = cf
});
}
}
foreach (var rcid in CompetitionIds)
{
if (rc.Where(e => e.CompetitionId == rcid && e.RegattaId == regattaVM.RegattaId).Count() == 0)
{
_context.Regattas.Include(e => e.RegattaCompetitions).FirstOrDefault(m => m.RegattaId == regattaVM.RegattaId).RegattaCompetitions.Add(new RegattaCompetition {
RegattaId = regattaVM.RegattaId, CompetitionId = rcid
});
}
}
foreach (var rsfid in StartingFeeIds)
{
if (rsf.Where(e => e.StartingFeeId == rsfid && e.RegattaId == regattaVM.RegattaId).Count() == 0)
{
_context.Regattas.Include(e => e.RegattaStartingFees).FirstOrDefault(m => m.RegattaId == regattaVM.RegattaId).RegattaStartingFees.Add(new RegattaStartingFee {
RegattaId = regattaVM.RegattaId, StartingFeeId = rsfid
});
}
}
_context.SaveChanges();
foreach (var oldoc in roc)
{
if (!OldclassIds.Contains(oldoc.OldclassId))
{
regatta.RegattaOldclasses.Remove(oldoc);
}
}
foreach (var oldcf in rcf)
{
if (!CampingFeeIds.Contains(oldcf.CampingFeeId))
{
regatta.RegattaCampingFees.Remove(oldcf);
}
}
foreach (var oldrcid in rc)
{
if (!CompetitionIds.Contains(oldrcid.CompetitionId))
{
regatta.RegattaCompetitions.Remove(oldrcid);
}
}
foreach (var oldrsfid in rsf)
{
if (!StartingFeeIds.Contains(oldrsfid.StartingFeeId))
{
regatta.RegattaStartingFees.Remove(oldrsfid);
}
}
if (ModelState.IsValid)
{
try
{
_context.Update(regatta);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RegattaExists(regatta.RegattaId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ClubId"] = new SelectList(_context.Clubs, "ClubId", "ClubId", regatta.ClubId);
ViewData["WaterId"] = new SelectList(_context.Waters, "WaterId", "WaterId", regatta.WaterId);
ViewData["RegattaOldclasses"] = new MultiSelectList(_context.Oldclasses, "OldclassId", "Name", regattaVM.RegattaOldclasses.Select(e => e.OldclassId).ToList());
ViewData["RegattaCompetitions"] = new MultiSelectList(_context.Competitions, "CompetitionId", "Name", regattaVM.RegattaCompetitions.Select(e => e.CompetitionId).ToList());
ViewData["RegattaStartingFees"] = new MultiSelectList(_context.StartingFees, "StartingFeeId", "Name", regattaVM.RegattaStartingFees.Select(e => e.StartingFeeId).ToList());
ViewData["RegattaCampingFees"] = new MultiSelectList(_context.CampingFees, "CampingFeeId", "Name", regattaVM.RegattaCampingFees.Select(e => e.CampingFeeId).ToList());
return(View(regattaVM));
}
public void AddRegatta(Regatta regatta)
{
_repository.InsertEntity(regatta);
}
public IRegattaUserRecord CreateRegattaRecord(Regatta regatta)
{
return(new RegattaUserRecord(regatta));
}
