private List <Ticket> InitializeTickets(List <Ticket> tickets, IEasyTrainTicketsDbEntities dbContext)
{
for (int i = 0; i < tickets.Count; i++)
{
HashSet <int> ids = new HashSet <int>();
foreach (var id in tickets[i].conPartsId)
{
ids.Add(id);
}
List <ConnectionPart> parts = dbContext.ConnectionParts.Where(cp => ids.Contains(cp.Id)).ToList();
for (int j = 0; j < tickets[i].Seats.Count; j++)
{
tickets[i].ConnectionPath.Add(parts.Find(p => p.Id == tickets[i][j]));
}
Dictionary <int, int> dict = new Dictionary <int, int>();
foreach (var id in tickets[i].discountsId)
{
if (dict.ContainsKey(id))
{
dict[id]++;
}
else
{
dict.Add(id, 1);
}
}
foreach (var id in dict.Keys)
{
Discount discount = dbContext.Discounts.Where(d => d.Id == id).First();
tickets[i].Discounts.Add(discount, dict[id]);
}
}
return(tickets);
}
public ActionResult AddConnection(string stringConnection)
{
Connection connection = JsonConvert.DeserializeObject<Connection>(stringConnection);
addConnectionModel.EndInitializationConnection(connection);
if(Session["connections"] is List<Connection>)
{
List<Connection> connections = Session["connections"] as List<Connection>;
connections.Add(connection);
Session["connections"] = connections;
return RedirectToAction("ListConnections", new { page = 1 });
}
else
{
using (IEasyTrainTicketsDbEntities dbContext = unitOfWorkFactory.CreateUnitOfWork())
{
dbContext.Trains.Attach(connection.Train);
foreach (var part in connection.Parts)
{
dbContext.Routes.Attach(part.Route);
}
dbContext.Connections.Add(connection);
dbContext.SaveChanges();
}
return View("MySuccess", new ErrorViewModel() { ErrorMessage = "Udało się dodać wybrane połączenie" });
}
}
public List <ConnectionPathDTO> Search(FilterPathsDTO fp, IUnitOfWorkFactory unitOfWorkFactory)
{
List <Path> paths = Mapper.Map <List <PathDTO>, List <Path> >(fp.Paths);
List <ConnectionPath> conPaths = new List <ConnectionPath>();
IEasyTrainTicketsDbEntities[] dbContexts = new IEasyTrainTicketsDbEntities[paths.Count];
Parallel.For(0, paths.Count, i =>
{
dbContexts[i] = unitOfWorkFactory.CreateUnitOfWork();
List <ConnectionPath> candidatePaths = paths[i].SecondSearch(fp.UserTime, dbContexts[i]);
foreach (var conpath in candidatePaths)
{
conPaths.Add(conpath);
}
});
JourneyTimeFilter(ref conPaths);
StartTimeFilter(ref conPaths);
EndTimeFilter(ref conPaths);
return(Mapper.Map <List <ConnectionPath>, List <ConnectionPathDTO> >(conPaths));
}
public ActionResult PrepareReserveSeats(string conIds, string dictDiscount, decimal price)
{
TicketViewModel viewModel;
try
{
viewModel = new TicketViewModel(conIds, dictDiscount, price);
}
catch
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Wystąpił nieoczekiwany błąd."
}));
}
using (IEasyTrainTicketsDbEntities dbContext = unitOfFactory.CreateUnitOfWork())
{
if (!buyTicketModel.NextPart(viewModel, dbContext))
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Z przykrością informujemy, że nie ma wystarczającej ilości miejsc w wybranym połączeniu"
}));
}
}
return(View("ReserveSeats", viewModel));
}
public BuyTicketDiscountViewModel(IUnitOfWorkFactory unitOfFactory)
{
using (IEasyTrainTicketsDbEntities dbContext = unitOfFactory.CreateUnitOfWork())
{
discounts = dbContext.Discounts.ToList();
qualityDiscounts = new int[discounts.Count];
}
}
private List <ConnectionPart> ListOfConnections(int i, DateTime userTime, IEasyTrainTicketsDbEntities _dbContext)
{
Route route = Track[i];
return(_dbContext.ConnectionParts.Where(cp => cp.Route.Id == route.Id &&
(cp.StartTime.Day == userTime.Day || cp.StartTime.Day == userTime.Day + 1) &&
cp.StartTime.Month == userTime.Month).ToList());
}
private List <Ticket> InitializeTickets(List <Ticket> tickets, IEasyTrainTicketsDbEntities dbContext)
{
for (int i = 0; i < tickets.Count; i++)
{
HashSet <int> ids = new HashSet <int>();
foreach (var id in tickets[i].conPartsId)
{
ids.Add(id);
}
List <ConnectionPart> parts = dbContext.ConnectionParts.Where(cp => ids.Contains(cp.Id)).ToList();
for (int j = 0; j < tickets[i].Seats.Count; j++)
{
tickets[i].ConnectionPath.Add(parts.Find(p => p.Id == tickets[i][j]));
}
Dictionary <int, int> dict = new Dictionary <int, int>();
int capacity = dbContext.Discounts.ToList().Count();
tickets[i].ListDiscount = new int[capacity].ToList();
for (int j = 0; j < tickets[i].ListDiscount.Count; j++)
{
tickets[i].ListDiscount[j] = 0;
}
foreach (var id in tickets[i].discountsId)
{
if (dict.ContainsKey(id))
{
dict[id]++;
}
else
{
dict.Add(id, 1);
}
tickets[i].ListDiscount[id - 1]++;
}
foreach (var id in dict.Keys)
{
Discount discount = dbContext.Discounts.Where(d => d.Id == id).First();
tickets[i].Discounts.Add(discount, dict[id]);
}
tickets[i].ConnectionPath.WriteConnection();
tickets[i].ConnectionPath.Initialize();
decimal count = 0;
foreach (var key in tickets[i].Discounts.Keys)
{
count += (decimal)(tickets[i].Discounts[key] * key.Percent);
}
tickets[i].Price = Math.Round(count * tickets[i].ConnectionPath.Price, 2);
tickets[i].Way = new List <string>();
for (int k = 0; k < tickets[i].ConnectionPath.Count; k++)
{
tickets[i].Way.Add(string.Format("{0,15} => {1,15} Odjazd: {2,7} Przyjazd: {3,7} Pociąg: {4,10} Zarezerwowane miejsca: {5,10}",
tickets[i].ConnectionPath[k].Route.From, tickets[i].ConnectionPath[k].Route.To, tickets[i].ConnectionPath[k].StartTime.ToShortTimeString(),
tickets[i].ConnectionPath[k].EndTime.ToShortTimeString(), tickets[i].ConnectionPath[k].Connection.Name, string.Join(",", tickets[i].Seats[k])));
}
}
tickets = tickets.OrderByDescending(t => t.ConnectionPath.StartTime).ThenByDescending(t => t.ConnectionPath.EndTime).ToList();
return(tickets);
}
public ActionResult PrepareAddConnection()
{
AddConnectionViewModel viewModel;
using (IEasyTrainTicketsDbEntities dbContext = unitOfWorkFactory.CreateUnitOfWork())
{
viewModel = new AddConnectionViewModel(dbContext);
}
ViewBag.Date = (DateTime)Session["Date"];
return View(viewModel);
}
public AddConnectionViewModel(IEasyTrainTicketsDbEntities dbContext)
{
List <Train> trains = dbContext.Trains.ToList();
Trains = new List <string>();
foreach (var t in trains)
{
Trains.Add(String.Format("{0}. {1}", t.Id, t.Type));
}
}
public List <Ticket> GetTicketsUser(IEasyTrainTicketsDbEntities dbContext, PagingInfo PagingInfo)
{
ApplicationUser user = System.Web.HttpContext.Current.GetOwinContext().GetUserManager <ApplicationUserManager>().FindById(System.Web.HttpContext.Current.User.Identity.GetUserId());
List <Ticket> listTickets = CreateTickets(user);
PagingInfo.TotalItems = listTickets.Count();
listTickets = InitializeTickets(listTickets, dbContext);
listTickets = listTickets.Skip((PagingInfo.CurrentPage - 1) * PagingInfo.ItemsPerPage).Take(PagingInfo.ItemsPerPage).ToList();
return(listTickets);
}
private int Min(int i, DateTime userTime, IEasyTrainTicketsDbEntities _dbContext)
{
var list = ListOfConnections(i, userTime, _dbContext);
if (list.Count == 0)
{
return(int.MaxValue);
}
return(list.Min(cp => SqlMethods.DateDiffMinute(userTime, cp.StartTime) >= 0 ?
SqlMethods.DateDiffMinute(userTime, cp.StartTime) : int.MaxValue));
}
public bool DeleteTicket(TicketDTO ticketDTO, IEasyTrainTicketsDbEntities dbContext)
{
var list = dbContext.Users.Where(u => u.Id == ticketDTO.User.Id && u.Password == ticketDTO.User.Password).ToList();
if (list.Count == 0)
{
return(false);
}
User user = list.First();
Ticket ticket = AutoMapper.Mapper.Map <TicketDTO, Ticket>(ticketDTO);
string ticketString = CreateStringTicket(ticket);
string userTickets = user.Tickets;
int index = userTickets.IndexOf(ticketString);
string newTickets;
if (index < 0)
{
return(false);
}
else if (ticketString.Length == userTickets.Length)
{
newTickets = "";
}
else if (index == userTickets.Length - ticketString.Length)
{
newTickets = userTickets.Remove(index - 1, ticketString.Length + 1);
}
else
{
newTickets = userTickets.Remove(index, ticketString.Length + 1);
}
user.Tickets = newTickets;
for (int i = 0; i < ticket.Count; i++)
{
var tmp = ticket.ConnectionPath[i];
ticket.ConnectionPath[i] = dbContext.ConnectionParts.Where(cp => cp.Id == tmp.Id).First();
if (ticket.ConnectionPath[i].Seats == "")
{
ticket.ConnectionPath[i].Seats = string.Join(",", ticket.Seats[i]).Replace(',', ';');
}
else
{
ticket.ConnectionPath[i].Seats = String.Format("{0};{1}", ticket.ConnectionPath[i].Seats, string.Join(",", ticket.Seats[i]).Replace(',', ';'));
}
ticket.ConnectionPath[i].FreeSeats += ticket.Seats[i].Length;
}
dbContext.SaveChanges();
return(true);
}
private ConnectionPart FindBestConnectionPart(int i, DateTime userTime, IEasyTrainTicketsDbEntities dbContext)
{
int minTime = Min(i, userTime, dbContext);
if (minTime > 300)
{
return(null);
}
ConnectionPart conPart = ListOfConnections(i, userTime, dbContext).Where(cp =>
SqlMethods.DateDiffMinute(userTime, cp.StartTime) == minTime).First();
return(conPart);
}
public bool NextPart(TicketViewModel ticketViewModel, IEasyTrainTicketsDbEntities dbContext)
{
if (ticketViewModel.SeatsChoose != null)
{
for (int i = 0; i < ticketViewModel.CountParts; i++)
{
ticketViewModel.Seats.Add(ticketViewModel.SeatsChoose.ToArray());
}
ticketViewModel.Way.Add(String.Format("{0,15} ==> {1,15} - Pociąg: {2,15} Zarezerwowane miejsca: {3} ", ticketViewModel.FromStation, ticketViewModel.EndStation, ticketViewModel.ConnectionsParts[ticketViewModel.Seats.Count - 1].Connection.Name, string.Join(",", ticketViewModel.Seats.Last())));
}
if (ticketViewModel.Seats.Count == ticketViewModel.ConnectionsParts.Count)
{
return(true);
}
int part, to;
part = to = ticketViewModel.Seats.Count;
ticketViewModel.FromStation = ticketViewModel.ConnectionsParts[part].Route.From;
while (to + 1 < ticketViewModel.ConnectionsParts.Count && ticketViewModel.ConnectionsParts[to].Connection.Id == ticketViewModel.ConnectionsParts[to + 1].Connection.Id)
{
to++;
}
ticketViewModel.EndStation = ticketViewModel.ConnectionsParts[to].Route.To;
if (ticketViewModel.ConnectionsParts[to].Connection.Train.Type == "Pośpieszny")
{
ticketViewModel.SourcePicture = "/Content/Images/pospMsc.png"; // popraw
}
else if (ticketViewModel.ConnectionsParts[to].Connection.Train.Type == "Ekspres")
{
ticketViewModel.SourcePicture = "/Content/Images/exMsc.png"; // popraw
}
ticketViewModel.FreeSeats = GetSeats(ticketViewModel.ConnectionsParts, part, to, dbContext);
if (ticketViewModel.FreeSeats.Count < ticketViewModel.Count)
{
ticketViewModel.EndStation = ticketViewModel.ConnectionsParts[part].Route.To;
to = part;
ticketViewModel.FreeSeats = GetSeats(ticketViewModel.ConnectionsParts, part, to, dbContext);
if (ticketViewModel.FreeSeats.Count < ticketViewModel.Count)
{
//SendMessage(string.Format("Zostało miejsc: {0}", ticketViewModel.FreeSeats.Count));
//IsOK = false;
//Cancel();
return(false);
}
}
ticketViewModel.CountParts = to - part + 1;
return(true);
}
public List <TicketDTO> GetTicketsUser(string loginUser, IEasyTrainTicketsDbEntities dbContext)
{
var list = dbContext.Users.Where(u => u.Login == loginUser).ToList();
if (list.Count == 0)
{
return(null);
}
User user = list.First();
List <Ticket> listTickets = CreateTickets(user);
listTickets = InitializeTickets(listTickets, dbContext);
return(AutoMapper.Mapper.Map <List <Ticket>, List <TicketDTO> >(listTickets));
}
public UserDTO Registration(UserDTO userDTO, IEasyTrainTicketsDbEntities dbcontext)
{
var record = dbcontext.Users.Where((u) => u.Login == userDTO.Login);
User user = Mapper.Map <UserDTO, User>(userDTO);
if (record.Count() == 1)
{
return(null);
}
dbcontext.Users.Add(user);
dbcontext.SaveChanges();
userDTO = Mapper.Map <User, UserDTO>(user);
return(userDTO);
}
public UserDTO ChangePassword(ChangePasswordDTO changePasswordDTO, IEasyTrainTicketsDbEntities dbcontext)
{
User user = Mapper.Map <ChangePasswordDTO, User>(changePasswordDTO);
var record = dbcontext.Users.Where((u) => u.Login == changePasswordDTO.Login);
if (record.Count() == 0 || record.ToList()[0].Password != user.Password)
{
return(null);
}
record.ToList()[0].Password = changePasswordDTO.NewPassword;
return(Mapper.Map <User, UserDTO>(user));
}
public ActionResult ReserveSeats(string ticket, TicketViewModel ticketViewModel)
{
TicketViewModel viewModel;
try
{
viewModel = JsonConvert.DeserializeObject <TicketViewModel>(ticket);
}
catch
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Wystąpił nieoczekiwany błąd."
}));
}
if (viewModel == null)
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Wystąpił nieoczekiwany błąd."
}));
}
viewModel.SeatsChoose = ticketViewModel.SeatsChoose;
if (viewModel.SeatsChoose.Count != viewModel.Count)
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Wybrano niepoprawną liczbę miejsc."
}));
}
using (IEasyTrainTicketsDbEntities dbContext = unitOfFactory.CreateUnitOfWork())
{
if (!buyTicketModel.NextPart(viewModel, dbContext))
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Z przykrością informujemy, że nie ma wystarczającej ilości miejsc w wybranym połączeniu"
}));
}
}
ModelState.Clear();
if (buyTicketModel.IsEnd(viewModel))
{
return(View("SummaryReservation", viewModel));
}
return(View(viewModel));
}
public void AddConnectionPart(AddConnectionViewModel viewModel, IEasyTrainTicketsDbEntities dbContext, Connection connection)
{
List <Route> routes = dbContext.Routes.ToList();
string idRoute = viewModel.SelectRoute.Split('.').First();
int id = Int16.Parse(idRoute);
Route route = routes.Where(r => r.Id == id).First();
ConnectionPart conPart = new ConnectionPart()
{
Route = route,
Connection = connection
};
if (connection.Parts.Count == 0)
{
conPart.StartTime = viewModel.StartTime;
conPart.EndTime = conPart.StartTime.AddMinutes(viewModel.Variance + route.BestTime);
}
else
{
conPart.StartTime = connection.Parts.Last().EndTime.AddMinutes(viewModel.StopTime);
conPart.EndTime = conPart.StartTime.AddMinutes(viewModel.Variance + route.BestTime);
}
string seats = @"11;12;13;14;15;16;17;18;21;22;23;24;25;26;27;28;31;32;33;34;35;36;37;38;41;42;43;44;45;46;47;48;51;52;53;54;55;56;57;58;61;62;63;64;65;66;67;68;71;72;73;74;75;76;77;78;81;82;83;84;85;86;87;88;91;92;93;94;95;96;97;98;101;102;103;104;105;106;107;108";
string expressSeats = @"11;12;13;14;15;16;21;22;23;24;25;26;31;32;33;34;35;36;41;42;43;44;45;46;51;52;53;54;55;56;61;62;63;64;65;66;71;72;73;74;75;76;81;82;83;84;85;86;91;92;93;94;95;96;101;102;103;104;105;106";
if (connection.Train.Type == "Ekspres")
{
conPart.Seats = expressSeats;
conPart.FreeSeats = 60;
}
else if (connection.Train.Type == "Pośpieszny")
{
conPart.Seats = seats;
conPart.FreeSeats = 80;
}
string endStation = viewModel.SelectRoute.Split('>').Last();
endStation = endStation.Substring(1);
foreach (var r in routes.Where(r => r.From == endStation))
{
viewModel.AvailableRoutes.Add(String.Format("{0}. {1} => {2}", r.Id, r.From, r.To));
}
viewModel.SelectRoute = null;
connection.Parts.Add(conPart);
viewModel.Connection.Connection = connection;
}
public bool DeleteTicket(Ticket ticket, IEasyTrainTicketsDbEntities dbContext, ApplicationUserManager userManager)
{
ApplicationUser user = System.Web.HttpContext.Current.GetOwinContext().GetUserManager <ApplicationUserManager>().FindById(System.Web.HttpContext.Current.User.Identity.GetUserId());
string ticketString = ticket.StringTicket;
string userTickets = user.Tickets;
int index = userTickets.IndexOf(ticketString);
string newTickets;
if (index < 0)
{
return(false);
}
else if (ticketString.Length == userTickets.Length)
{
newTickets = "";
}
else if (index == userTickets.Length - ticketString.Length)
{
newTickets = userTickets.Remove(index - 1, ticketString.Length + 1);
}
else
{
newTickets = userTickets.Remove(index, ticketString.Length + 1);
}
user.Tickets = newTickets;
for (int i = 0; i < ticket.conPartsId.Count; i++)
{
int id = ticket.conPartsId[i];
ConnectionPart conPart = dbContext.ConnectionParts.Where(cp => cp.Id == id).First();
if (conPart.Seats == "")
{
conPart.Seats = string.Join(",", ticket.Seats[i]).Replace(',', ';');
}
else
{
conPart.Seats = String.Format("{0};{1}", conPart.Seats, string.Join(",", ticket.Seats[i]).Replace(',', ';'));
}
conPart.FreeSeats += ticket.Seats[i].Length;
}
dbContext.SaveChanges();
userManager.Update(user);
return(true);
}
public List <ConnectionPath> SecondSearch(DateTime userTime, IEasyTrainTicketsDbEntities _dbContext)
{
List <ConnectionPath> conPaths = new List <ConnectionPath>();
List <ConnectionPart> startParts = ListOfConnections(0, userTime, _dbContext).
Where(cp => SqlMethods.DateDiffMinute(userTime, cp.StartTime) >= 0 &&
SqlMethods.DateDiffHour(userTime, cp.StartTime) < 20).ToList();
foreach (var startPart in startParts)
{
userTime = startPart.EndTime;
ConnectionPath conPath = new ConnectionPath();
conPath.Add(startPart);
for (int i = 1; i < Count; i++)
{
var conpart = FindBestConnectionPart(i, userTime, _dbContext);
if (conpart == null)
{
conPath = null;
break;
}
conPath.Add(conpart);
Connection con = conpart.Connection;
List <ConnectionPart> list = con.Parts.ToList();
int k = list.FindIndex(cp => cp.Id == conpart.Id);
while (i + 1 < Count && k + 1 < list.Count && list[k + 1].Route.Id == Track[i + 1].Id)
{
conPath.Add(list[k + 1]);
k++;
i++;
}
userTime = list[k].EndTime;
}
if (conPath != null)
{
if (conPath.Changes < 5)
{
if (TimeSpan.Compare(conPath.ConnectionsParts.Last().EndTime - conPath.ConnectionsParts.First().StartTime, new TimeSpan(25, 0, 0)) < 0)
{
conPaths.Add(conPath);
}
}
}
}
return(conPaths);
}
public void CreateConnection(AddConnectionViewModel viewModel, IEasyTrainTicketsDbEntities dbContext)
{
Connection connection = new Connection();
string idTrain = viewModel.SelectTrain.Split('.')[0];
int id = Int16.Parse(idTrain);
connection.Name = viewModel.Name;
connection.Train = dbContext.Trains.Where(t => t.Id == id).First();
connection.Parts = new List <ConnectionPart>();
List <Route> routes = dbContext.Routes.ToList();
foreach (var r in routes)
{
viewModel.AvailableRoutes.Add(String.Format("{0}. {1} => {2}", r.Id, r.From, r.To));
}
viewModel.Connection.Connection = connection;
}
public List <ConnectionPath> Search(SearchParameters searchParameters, IUnitOfWorkFactory unitOfWorkFactory)
{
List <Path> paths = SearchPaths(searchParameters.From, searchParameters.Middle, searchParameters.To);
List <ConnectionPath> conPaths = new List <ConnectionPath>();
IEasyTrainTicketsDbEntities[] dbContexts = new IEasyTrainTicketsDbEntities[paths.Count];
Parallel.For(0, paths.Count, i =>
{
dbContexts[i] = unitOfWorkFactory.CreateUnitOfWork();
List <ConnectionPath> candidatePaths = paths[i].SecondSearch(searchParameters.UserTime, dbContexts[i]);
foreach (var conpath in candidatePaths)
{
conPaths.Add(conpath);
}
});
foreach (var conPath in conPaths)
{
conPath.Initialize();
}
if (searchParameters.IsWithoutChange)
{
WithoutChangeFilter(ref conPaths);
}
if (!searchParameters.IsExpress)
{
WithoutExpressFilter(ref conPaths);
}
JourneyTimeFilter(ref conPaths);
StartTimeFilter(ref conPaths);
EndTimeFilter(ref conPaths);
TakeBestFilter(ref conPaths);
return(conPaths);
}
public ActionResult PrepareListConnections(DateViewModel dateViewModel)
{
List<Connection> connections;
using (IEasyTrainTicketsDbEntities dbContext = unitOfWorkFactory.CreateUnitOfWork())
{
int number = dbContext.Connections.Where(c => c.Parts.FirstOrDefault().StartTime.Day == dateViewModel.Date.Day && c.Parts.FirstOrDefault().StartTime.Month == dateViewModel.Date.Month && c.Parts.FirstOrDefault().StartTime.Year == dateViewModel.Date.Year).Count();
if (number > 0)
{
return View("MyError", new ErrorViewModel() { ErrorMessage = "Na ten dzień istnieja już połączenia" });
}
connections = ConnectionsGenerator.PerDay(dateViewModel.Date, dbContext);
}
PagingInfo PagingInfo = new PagingInfo() { CurrentPage = 1, ItemsPerPage = PageSize, TotalItems = connections.Count };
ListConnectionsViewModel viewModel = new ListConnectionsViewModel();
viewModel.Show(connections, PagingInfo);
Session["connections"] = connections;
Session["Date"] = dateViewModel.Date;
return View("ListConnections", viewModel);
}
public ActionResult AddConnectionParts(AddConnectionViewModel viewModel, string stringConnection)
{
if (viewModel.SelectRoute == null)
{
DateTime date = (DateTime)Session["Date"];
viewModel.StartTime = date.Date + viewModel.TimeOfDay;
using (IEasyTrainTicketsDbEntities dbContext = unitOfWorkFactory.CreateUnitOfWork())
{
addConnectionModel.CreateConnection(viewModel, dbContext);
}
}
else
{
using (IEasyTrainTicketsDbEntities dbContext = unitOfWorkFactory.CreateUnitOfWork())
{
addConnectionModel.AddConnectionPart(viewModel, dbContext, JsonConvert.DeserializeObject<Connection>(stringConnection));
}
}
ModelState.Clear();
return View(viewModel);
}
public ActionResult SummaryPrice(string SelectedDiscount, string conIds)
{
List <int> qualDiscount;
try
{
qualDiscount = JsonConvert.DeserializeObject <int[]>(SelectedDiscount).ToList();
}
catch
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Wybrane zniżki mają być liczbami."
}));
}
if (qualDiscount == null || qualDiscount.Sum() == 0 || qualDiscount.Count != 4)
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Wybierz coś."
}));
}
foreach (var discount in qualDiscount)
{
if (discount < 0 || discount > 5)
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Wybrane ilości mają być liczbami od 0 do 5."
}));
}
}
BuyTicketSummaryPriceViewModel viewModel;
using (IEasyTrainTicketsDbEntities dbContext = unitOfFactory.CreateUnitOfWork())
{
viewModel = new BuyTicketSummaryPriceViewModel(dbContext, conIds, SelectedDiscount);
}
return(View(viewModel));
}
public UserDTO SignIn(UserDTO userDTO, IEasyTrainTicketsDbEntities dbcontext)
{
var record = dbcontext.Users.Where(u => u.Login == userDTO.Login);
if (record.Count() == 1)
{
string sqlpass = record.First().Password;
if (sqlpass == userDTO.Password)
{
userDTO = AutoMapper.Mapper.Map <User, UserDTO>(record.ToList()[0]);
return(userDTO);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
public ActionResult RandomSeats(string conIds, string dictDiscount, decimal price)
{
TicketViewModel viewModel = new TicketViewModel(conIds, dictDiscount, price);
using (IEasyTrainTicketsDbEntities dbContext = unitOfFactory.CreateUnitOfWork())
{
do
{
if (!buyTicketModel.NextPart(viewModel, dbContext))
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Z przykrością informujemy, że nie ma wystarczającej ilości miejsc w wybranym połączeniu"
}));
}
viewModel.SeatsChoose = viewModel.FreeSeats.GetRange(0, viewModel.Count);
} while (!buyTicketModel.IsEnd(viewModel));
}
ModelState.Clear();
return(View("SummaryReservation", viewModel));
}
public ActionResult AddConnections(DateViewModel viewModel)
{
using(IEasyTrainTicketsDbEntities dbContext = unitOfWorkFactory.CreateUnitOfWork())
{
List<Connection> connections = Session["connections"] as List<Connection>;
foreach (var con in connections)
{
con.Train = dbContext.Trains.Where(c => c.Id == con.Train.Id).First();
dbContext.Trains.Attach(con.Train);
foreach (var part in con.Parts)
{
part.Route = dbContext.Routes.Where(r => r.Id == part.Route.Id).First();
dbContext.Routes.Attach(part.Route);
}
dbContext.Connections.Add(con);
}
dbContext.SaveChanges();
}
Session["connections"] = null;
return View("MySuccess", new ErrorViewModel() { ErrorMessage = "Udało się dodać rozkład jazdy na wybrany dzień" });
}
public BuyTicketSummaryPriceViewModel(IEasyTrainTicketsDbEntities dbContext, string conIds, string qualityDiscount)
{
List <int> qualDiscount = JsonConvert.DeserializeObject <int[]>(qualityDiscount).ToList();
Dict = new Dictionary <Discount, int>();
List <Discount> discounts = dbContext.Discounts.ToList();
for (int i = 0; i < discounts.Count; i++)
{
Dict.Add(discounts[i], qualDiscount[i]);
}
List <int> list = new List <int>();
foreach (var key in Dict.Keys)
{
list.Add(Dict[key]);
}
ListDiscount = JsonConvert.SerializeObject(list);
ConIds = conIds;
List <ConnectionPart> conParts = JsonConvert.DeserializeObject <List <ConnectionPart> >(conIds);
ConnectionPath conPath = new ConnectionPath()
{
ConnectionsParts = conParts
};
conPath.Initialize();
decimal count = 0;
foreach (var key in Dict.Keys)
{
count += (decimal)(Dict[key] * key.Percent);
}
Price = Math.Round(count * conPath.Price, 2);
conPath.WriteConnection();
Way = conPath.Way;
}
