private ConcertModel PopulateSingleConcertFromDbReader(SqlDataReader dbReader)
{
var concertPerformer = new PerformerModel
{
PerformerId = dbReader.GetInt32(dbReader.GetOrdinal(@"performerId")),
FirstName = dbReader.GetString(dbReader.GetOrdinal(@"performerFirstName")),
LastName = dbReader.GetString(dbReader.GetOrdinal(@"performerLastName")),
ShortName = dbReader.GetString(dbReader.GetOrdinal(@"performerShortName"))
};
var concertToReturn = new ConcertModel
{
ConcertId = dbReader.GetInt32(dbReader.GetOrdinal(@"concertId")),
ConcertDate = dbReader.GetDateTime(dbReader.GetOrdinal(@"concertDate")),
ConcertName = dbReader.GetString(dbReader.GetOrdinal(@"concertName")),
VenueId = dbReader.GetInt32(dbReader.GetOrdinal(@"venueId")),
Description = dbReader.GetString(dbReader.GetOrdinal(@"concertDescription")),
PerformerId = dbReader.GetInt32(dbReader.GetOrdinal(@"concertPerformerId")),
PerformerModel = concertPerformer,
SaveToDbServer = (dbReader.IsDBNull(dbReader.GetOrdinal(@"saveToDatabase")))
? ((int)ServerTargetEnum.Primary)
: ((ServerTargetEnum)dbReader.GetInt32(dbReader.GetOrdinal(@"saveToDatabase")))
};
return(concertToReturn);
}
public ConcertModel Getevents()
{
var concertModel = new ConcertModel();
var reader = _eventsDataProvider.Getevents();
int i = 0;
while (reader.Read())
{
var events = new EventsModel
{
EventsId = reader.GetInt32(0),
VenueId = reader.GetInt32(1),
Artist = reader.GetString(2),
Description = reader.GetString(3),
Date = reader.GetString(4),
StartTime = reader.GetString(5),
EndTime = reader.GetString(6),
};
var venue = new VenueModel
{
LocationId = reader.GetInt32(1),
Name = reader.GetString(7),
Address = reader.GetString(8),
PhoneNumber = reader.GetString(9),
EmailAddress = reader.GetString(10)
};
concertModel.Events.Add(i, events);
concertModel.Venue.Add(i, venue);
i += 1;
}
return(concertModel);
}
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));
}
public async Task <IActionResult> BookTicket(int?id, int amount)
{
ConcertModel concert = await _context.Concerts.SingleOrDefaultAsync(c => c.Id == id);
if (concert == null)
{
return(NotFound());
}
else
{
var currentConcert = await _context.Concerts
.SingleOrDefaultAsync(m => m.Id == id);
if (!ValidateBookingData(currentConcert, id, amount))
{
return(RedirectToAction("Details", new { id = id }));
}
else
{
string userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var currentUser = await _userManager.GetUserAsync(HttpContext.User);
TicketModel ticket = new TicketModel
{
IdConcert = currentConcert.Id,
IdUser = userId,
Amount = amount
};
currentConcert.TicketsLeft -= amount;
await _context.Tickets.AddAsync(ticket);
await _context.SaveChangesAsync();
string emailAddress = /*currentUser.Email;
* emailAddress =*/"*****@*****.**";
_emailSender.SendBookingConfirmationAsync(_appEnvironment, emailAddress, amount, currentConcert);
TempData["result"] = "Your ticket is booked. Email confirmation is send to your email.";
TempData["success"] = true;
return(RedirectToAction("Details", new { id = id }));
}
}
}
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 bool ValidateBookingData(ConcertModel currentConcert, int?id, int amount)
{
if (amount < 1)
{
TempData["result"] = "Ticket amount must be a positive number equal or greater than 1.";
TempData["success"] = false;
return(false);
}
else if (currentConcert.TicketsLeft == 0)
{
TempData["result"] = "No more tickets left";
TempData["success"] = false;
return(false);
}
else if (currentConcert.TicketsLeft > 0 && currentConcert.TicketsLeft < amount)
{
TempData["result"] = "Only " + currentConcert.TicketsLeft + " tickets left.";
TempData["success"] = false;
return(false);
}
return(true);
}
public ConcertModel GetConcertById(int concertId)
{
ConcertModel concertModelToReturn = null;
using (var dbConnection = WingtipTicketApp.CreateTenantConnectionDatabase1())
{
try
{
dbConnection.Open();
var getSingleConcertQuery = String.Format("{0} WHERE concerts.ConcertId={1} {2}", ConstGetAllConcertsQuery, concertId, ConstOrderByConcertDate);
var queryCommand = new SqlCommand(getSingleConcertQuery, dbConnection);
using (var reader = queryCommand.ExecuteReader())
{
try
{
if (reader.Read())
{
concertModelToReturn = PopulateSingleConcertFromDbReader(reader);
}
}
finally
{
reader.Close();
}
}
}
finally
{
dbConnection.Close();
}
}
return(concertModelToReturn);
}
private void PrepareData(ref int artistId, ref int cityId, ref int venueId, int eventId, List <LookupViewModel> eventList, List <LookupViewModel> artistList)
{
#region - Prepare selections -
if (artistId == 0)
{
artistId = -1;
}
if (cityId == 0)
{
cityId = -1;
}
if (venueId == 0)
{
venueId = -1;
}
#endregion
var selectedConcert = new ConcertModel();
if (eventId > 0 && eventList.Any(a => a.Value != null && (int)a.Value == eventId))
{
selectedConcert = _concertRepository.GetConcerts(venueId, true).First(a => a.ConcertId == eventId);
artistId = selectedConcert.PerformerId;
artistList.RemoveAll(a => a.Value != selectedConcert.PerformerId);
}
else if (eventId == 0 || eventId == -1)
{
selectedConcert.ConcertId = -1;
}
}
public ConcertModel SaveNewConcert(String concertName, String concertDescription, DateTime concertDateTime, ServerTargetEnum saveToDatabase, int concertVenueId, int performerId)
{
ConcertModel concertModelToReturn = null;
var tempDs = new DataSet();
#region Insert
var insertQuery = String.Format(ConstInsertNewConcert, concertName, concertDescription, concertDateTime, ConstConcertduration, concertVenueId, performerId, (int)saveToDatabase);
using (var insertConnection = WingtipTicketApp.CreateTenantConnectionDatabase1())
{
insertConnection.Open();
using (var insertCommand = new SqlCommand(insertQuery, insertConnection))
{
insertCommand.ExecuteNonQuery();
}
insertConnection.Close();
insertConnection.Dispose();
}
#endregion
#region Get Information
var getCommandQuery = string.Format("{0} WHERE (concerts.ConcertName='{1}' AND concerts.VenueId={2} AND concerts.PerformerId={3}) {4}", ConstGetAllConcertsQuery, concertName, concertVenueId, performerId, ConstOrderByConcertDate);
using (var getConnection = WingtipTicketApp.CreateTenantConnectionDatabase1())
{
getConnection.Open();
using (var reader = new SqlCommand(getCommandQuery, getConnection).ExecuteReader())
{
if (reader.Read())
{
concertModelToReturn = PopulateSingleConcertFromDbReader(reader);
}
}
getConnection.Close();
getConnection.Dispose();
}
#endregion
#region Populate Ticket Levels
var i = 1;
var seatSectionQuery = string.Format(@"SELECT * FROM [SeatSection] Where VenueId={0}", concertVenueId);
using (var seatCommand = new SqlCommand(seatSectionQuery, WingtipTicketApp.CreateTenantConnectionDatabase1()))
{
using (var seatDataAdapter = new SqlDataAdapter(seatCommand))
{
seatDataAdapter.Fill(tempDs);
if (tempDs.Tables.Count > 0 && tempDs.Tables[0].Rows.Count > 0)
{
foreach (DataRow drSeat in tempDs.Tables[0].Rows)
{
var ticketLevelInsert = string.Format(@"INSERT INTO [TicketLevels] (Description, SeatSectionId, ConcertId, TicketPrice) Values('Level-{0}', {0}, {1}, '{2}')", drSeat["SeatSectionId"].ToString(), concertModelToReturn.ConcertId, (50 + (5 * i++)).ToString() + ".00");
using (var ticketConnection = WingtipTicketApp.CreateTenantConnectionDatabase1())
{
ticketConnection.Open();
using (var ticketCommand = new SqlCommand(ticketLevelInsert, ticketConnection))
{
ticketCommand.ExecuteNonQuery();
}
ticketConnection.Close();
ticketConnection.Dispose();
}
}
}
}
}
#endregion
LogAction("Added new concert " + concertName + " for venueId " + concertVenueId);
return(concertModelToReturn);
}
public static void SendBookingConfirmationAsync(this IEmailSender emailSender, IHostingEnvironment appEnvironment,
string emailAddress, int amount, ConcertModel currentConcert)
{
MailMessage mail = new MailMessage("*****@*****.**", emailAddress);
mail.Subject = "Ticket Booking";
SmtpClient smtpClient = new SmtpClient("smtp.gmail.com", 587);
smtpClient.Credentials = new System.Net.NetworkCredential()
{
UserName = "******",
Password = "******"
};
mail.IsBodyHtml = true;
var pathToFile = appEnvironment.WebRootPath
+ Path.DirectorySeparatorChar.ToString()
+ "templates"
+ Path.DirectorySeparatorChar.ToString()
+ "concertEmailPage.html";
using (StreamReader reader = System.IO.File.OpenText(pathToFile))
{
mail.Body = reader.ReadToEnd();
}
//mail.Body = String.Format(mail.Body, emailAddress, currentConcert.Name, amount.ToString()
// , currentConcert.Performer, currentConcert.Type, currentConcert.Place, currentConcert.Price.ToString()
// , currentConcert.TicketsAmount.ToString(), currentConcert.TicketsLeft.ToString()
// , String.Format("{0:d/M/yyyy HH:mm:ss}", currentConcert.Date)
// , String.Format("{0:d/M/yyyy HH:mm:ss}", DateTime.Now)
// );
mail.Body = mail.Body.Replace("{user}", emailAddress);
mail.Body = mail.Body.Replace("{name}", currentConcert.Name);
mail.Body = mail.Body.Replace("{amount}", amount.ToString());
mail.Body = mail.Body.Replace("{performer}", currentConcert.Performer);
mail.Body = mail.Body.Replace("{type}", currentConcert.Type);
mail.Body = mail.Body.Replace("{place}", currentConcert.Place);
mail.Body = mail.Body.Replace("{price}", currentConcert.Price.ToString());
mail.Body = mail.Body.Replace("{ticketsAmount}", currentConcert.TicketsAmount.ToString());
mail.Body = mail.Body.Replace("{ticketsLeft}", currentConcert.TicketsLeft.ToString());
mail.Body = mail.Body.Replace("{date}", String.Format("{0:d/M/yyyy HH:mm:ss}", currentConcert.Date));
mail.Body = mail.Body.Replace("{now}", String.Format("{0:d/M/yyyy HH:mm:ss}", DateTime.Now));
smtpClient.EnableSsl = true;
ServicePointManager.ServerCertificateValidationCallback = delegate(object s,
System.Security.Cryptography.X509Certificates.X509Certificate certificate,
System.Security.Cryptography.X509Certificates.X509Chain chain,
System.Net.Security.SslPolicyErrors sslPolicyErrors)
{
return(true);
};
smtpClient.Send(mail);
}
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));
}
