public async Task EditConcert(ConcertViewModel vm)
{
var concert = await GetConcertByIdAsync(vm.Id);
if (concert == null)
{
throw new ArgumentException($"A concert with the given '{vm.Id}' was not found");
}
if (!string.IsNullOrEmpty(vm.BandName))
{
concert.BandName = vm.BandName;
}
if (!string.IsNullOrEmpty(vm.Name))
{
concert.Name = vm.Name;
}
if (vm.Capacity != null)
{
concert.Capacity = vm.Capacity ?? 0;
}
await _ctx.SaveChangesAsync();
}
public async Task <ActionResult> Create(ConcertViewModel concertInfo)
{
try
{
Artist artist = GetCurrentArtist();
Concert concert = new Concert()
{
ArtistId = artist.ArtistId,
ConcertDate = concertInfo.Concert.ConcertDate,
VenueName = concertInfo.Concert.VenueName,
VenueCapacity = concertInfo.Concert.VenueCapacity
};
Address addressToDb = concertInfo.Address;
string[] latLng = await GeoCode.GetLatLongFromApi(addressToDb);
addressToDb.Lat = latLng[0];
addressToDb.Lng = latLng[1];
context.Addresses.Add(addressToDb);
context.SaveChanges();
Address addressFromDb = context.Addresses.FirstOrDefault(a => a.AddressLine1 == concertInfo.Address.AddressLine1 && a.AddressLine2 == concertInfo.Address.AddressLine2 && a.City == concertInfo.Address.City && a.State == concertInfo.Address.State && a.ZipCode == concertInfo.Address.ZipCode);
concert.AddressId = addressFromDb.AddressId;
context.Concerts.Add(concert);
context.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task AddConcert(ConcertViewModel vm)
{
if (vm == null)
{
throw new ArgumentNullException(nameof(vm));
}
if (vm.BandName == null)
{
throw new ArgumentException("Band name is null");
}
if (vm.Name == null)
{
throw new ArgumentException("Name is null");
}
var concert = new Concert()
{
BandName = vm.BandName,
Name = vm.Name,
Capacity = vm.Capacity ?? 0
};
_ctx.Concerts.Add(concert);
await _ctx.SaveChangesAsync();
}
public async Task <IActionResult> Add(ConcertViewModel model)
{
if (ModelState.IsValid)
{
ConcertModel concert = await _context.Concerts.FirstOrDefaultAsync(u => u.Name == model.Name);
if (concert == null)
{
ConcertModel c = new ConcertModel(model);
if (model.Type == nameof(ClassicalConcertModel))
{
ClassicalConcertModel classicConcert = new ClassicalConcertModel(c);
classicConcert.VocalType = model.VocalType;
classicConcert.ClassicalConcertName = model.ClassicalConcertName;
classicConcert.Composer = model.Composer;
_context.ClassicalConcerts.Add(classicConcert);
}
else if (model.Type == nameof(OpenAirModel))
{
OpenAirModel openAir = new OpenAirModel(c);
openAir.DriveWay = model.DriveWay;
openAir.Headliner = model.Headliner;
_context.OpenAirs.Add(openAir);
}
else if (model.Type == nameof(PartyModel))
{
PartyModel party = new PartyModel(c);
party.AgeQualification = model.AgeQualification.Value;
_context.Parties.Add(party);
}
else
{
ModelState.AddModelError("", "Некорректные данные");
}
await _context.SaveChangesAsync();
return(RedirectToAction("Index", "Concerts"));
}
else
{
ModelState.AddModelError("", "Некорректные данные");
}
}
else
{
ModelState.AddModelError("", "Некорректные данные");
}
return(View(model));
}
// GET: Concert/Details/5
public ActionResult Details(int id)
{
Concert concert = context.Concerts.FirstOrDefault(c => c.ConcertId == id);
Address address = context.Addresses.FirstOrDefault(a => a.AddressId == concert.AddressId);
ConcertViewModel concertInfo = new ConcertViewModel()
{
Concert = concert,
Address = address,
FullAddress = ConcatAddress(address)
};
return(View(concertInfo));
}
public ActionResult PastConcerts()
{
Artist artist = GetCurrentArtist();
List <Concert> concerts = context.Concerts.Where(c => c.ArtistId == artist.ArtistId && c.ConcertDate < DateTime.Today).ToList();
List <ConcertViewModel> pastConcerts = new List <ConcertViewModel>();
foreach (Concert concert in concerts)
{
ConcertViewModel concertInfo = new ConcertViewModel();
concertInfo.Concert = concert;
concertInfo.Address = context.Addresses.FirstOrDefault(a => a.AddressId == concert.AddressId);
concertInfo.FullAddress = ConcatAddress(concertInfo.Address);
pastConcerts.Add(concertInfo);
}
return(View(pastConcerts));
}
public async Task <ConcertViewModel> GetConcertByIdAsync(int id)
{
var concertModel = await _ctx.Concerts.FirstOrDefaultAsync(x => x.Id == id);
if (concertModel == null)
{
return(null);
}
var rv = new ConcertViewModel()
{
BandName = concertModel.BandName, Name = concertModel.BandName, Capacity = concertModel.Capacity
};
return(rv);
}
public async Task <List <ConcertViewModel> > GetConcertsAsync()
{
var rv = new List <ConcertViewModel>();
var concerts = await _ctx.Concerts.ToListAsync();
foreach (var conert in concerts)
{
var vm = new ConcertViewModel()
{
BandName = conert.BandName, Name = conert.BandName, Capacity = conert.Capacity
};
rv.Add(vm);
}
return(rv);
}
public async Task <IActionResult> Details(int?id, int?page = null)
{
ViewBag.Page = page;
if (TempData["result"] != null)
{
ViewBag.Message = TempData["result"].ToString();
ViewBag.Message2 = TempData["success"];
TempData["result"] = null;
TempData["success"] = false;
}
if (id == null)
{
return(NotFound());
}
var concert = await _context.Concerts
.SingleOrDefaultAsync(m => m.Id == id);
if (concert == null)
{
return(NotFound());
}
ConcertViewModel model = new ConcertViewModel(concert);
var type = concert.GetType().Name;
if (type == nameof(ClassicalConcertModel))
{
ClassicalConcertModel classicalConcert = (ClassicalConcertModel)concert;
model.ClassicalConcertName = classicalConcert.ClassicalConcertName;
model.VocalType = classicalConcert.VocalType;
model.Composer = classicalConcert.Composer;
}
else if (type == nameof(OpenAirModel))
{
OpenAirModel openAir = (OpenAirModel)concert;
model.DriveWay = openAir.DriveWay;
model.Headliner = openAir.Headliner;
}
else
{
PartyModel party = (PartyModel)concert;
model.AgeQualification = party.AgeQualification;
}
return(View(model));
}
public ActionResult Route(int id)
{
TourViewModel tourInfo = new TourViewModel();
tourInfo.AllStops = context.Concerts.Where(c => c.TourId == id).ToList();
tourInfo.AllStopInfo = new List <ConcertViewModel>();
foreach (Concert concert in tourInfo.AllStops)
{
ConcertViewModel concertInfo = new ConcertViewModel();
concertInfo.Concert = concert;
concertInfo.Address = context.Addresses.FirstOrDefault(a => a.AddressId == concert.AddressId);
concertInfo.FullAddress = ConcatAddress(concertInfo.Address);
tourInfo.AllStopInfo.Add(concertInfo);
}
ConcertViewModel[] infoArray = tourInfo.AllStopInfo.ToArray();
ViewBag.StopInfo = infoArray;
return(View(tourInfo));
}
public async Task OnPost()
{
try
{
var vm = new ConcertViewModel()
{
BandName = BandName,
Capacity = Capacity,
Name = Name
};
await _controller.AddConcert(vm);
}
catch (Exception ex)
{
IsError = true;
ErrorMessage = ex.Message;
throw;
}
}
public async Task <IActionResult> Edit(int?id, int?page = null)
{
ViewBag.Page = page;
if (id == null)
{
return(NotFound());
}
ConcertModel concert = await _context.Concerts.SingleOrDefaultAsync(m => m.Id == id);
if (concert == null)
{
return(NotFound());
}
ConcertViewModel model = new ConcertViewModel(concert);
if (concert.Type == nameof(ClassicalConcertModel))
{
ClassicalConcertModel currentClassic = await _context.ClassicalConcerts.SingleOrDefaultAsync(c => c.Id == id);
model.ClassicalConcertName = currentClassic.ClassicalConcertName;
model.Composer = currentClassic.Composer;
model.VocalType = currentClassic.VocalType;
}
else if (concert.Type == nameof(OpenAirModel))
{
OpenAirModel currentOpenAir = await _context.OpenAirs.SingleOrDefaultAsync(c => c.Id == id);
model.Headliner = currentOpenAir.Headliner;
model.DriveWay = currentOpenAir.DriveWay;
}
else if (concert.Type == nameof(PartyModel))
{
PartyModel currentParty = await _context.Parties.SingleOrDefaultAsync(c => c.Id == id);
model.AgeQualification = currentParty.AgeQualification;
}
return(View(model));
}
public ConcertDto ConvertConcertViewModelToDto(ConcertViewModel viewModel)
{
return(new(viewModel.Id, viewModel.Date, viewModel.Name, viewModel.EventType, viewModel.Venue,
viewModel.VenueCostType, viewModel.MarketingCostType, viewModel.Capacity, viewModel.Sold,
viewModel.ArtistCosts, viewModel.ArtistCostType));
}
public ActionResult Create()
{
ConcertViewModel concertInfo = new ConcertViewModel();
return(View(concertInfo));
}
public async Task <IActionResult> Edit(int id, ConcertViewModel model, int?page = null)
{
ViewBag.Page = page;
if (id != model.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
ConcertModel concert = await _context.Concerts.SingleOrDefaultAsync(c => c.Id == id);
if (concert.Type == model.Type)
{
if (model.Type == nameof(ClassicalConcertModel))
{
ClassicalConcertModel currentClassic = await _context.ClassicalConcerts.SingleOrDefaultAsync(c => c.Id == id);
currentClassic.Update(model);
_context.Update(currentClassic);
}
else if (model.Type == nameof(OpenAirModel))
{
OpenAirModel currentOpenAir = await _context.OpenAirs.SingleOrDefaultAsync(c => c.Id == id);
currentOpenAir.Update(model);
_context.Update(currentOpenAir);
}
else if (model.Type == nameof(PartyModel))
{
PartyModel currentParty = await _context.Parties.SingleOrDefaultAsync(c => c.Id == id);
currentParty.Update(model);
_context.Update(currentParty);
}
}
else
{
if (model.Type == nameof(ClassicalConcertModel))
{
ClassicalConcertModel newConcert = new ClassicalConcertModel(concert);
newConcert.Update(model);
_context.Concerts.Add(newConcert);
}
else if (model.Type == nameof(OpenAirModel))
{
OpenAirModel newConcert = new OpenAirModel(concert);
newConcert.Update(model);
_context.Concerts.Add(newConcert);
}
else if (model.Type == nameof(PartyModel))
{
PartyModel newConcert = new PartyModel(concert);
newConcert.Update(model);
_context.Concerts.Add(newConcert);
}
_context.Concerts.Remove(concert);
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConcertExists(model.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public ConcertBase()
{
ViewModel = new ConcertViewModel(Id);
}
