protected IEnumerator CreateCampsiteOverTime(Campsite campsite)
{
//turn it into a proper campsite
Location location = campsite.worlditem.GetOrAdd <Location>();
location.State.Name.FileName = "Campsite_" + Mathf.Abs(campsite.worlditem.GetHashCode()).ToString();
location.State.Name.CommonName = "Campsite";
location.State.Type = "Campsite";
location.State.IsCivilized = true;
location.State.IsDangerous = false;
location.State.Transform.CopyFrom(location.worlditem.tr);
Revealable revealable = campsite.worlditem.GetOrAdd <Revealable>();
revealable.State.IconName = "MapIconCampsite";
revealable.State.LabelStyle = MapLabelStyle.MouseOver;
Visitable visitable = campsite.worlditem.GetOrAdd <Visitable>();
Player.Local.Surroundings.Reveal(campsite.worlditem.StaticReference);
WorldMap.MarkLocation(campsite.worlditem.StaticReference);
campsite.State.HasBeenCreated = true;
campsite.State.CreatedByPlayer = true;
campsite.RefreshFlag();
yield return(null); //wait a tick for the campsite to re-initialize
WorldItems.Get.Save(campsite.worlditem, true); //save state immediately - this will calculate stuff like chunk position
yield break;
}
public void OnPlaceCampsite(Campsite campsite)
{
if (campsite == ActiveCampsite)
{
if (WaterSourceAvailable)
{
if (Player.Local.Surroundings.IsOutside)
{
StartCoroutine(CreateCampsiteOverTime(campsite));
GUIManager.PostSuccess("Created new campsite");
}
else
{
campsite.State.HasBeenCreated = false;
GUIManager.PostDanger("Couldn't create campsite: not outside");
}
}
else
{
campsite.State.HasBeenCreated = false;
GUIManager.PostDanger("Couldn't create campsite: no water sources nearby");
}
}
StopPlacement();
}
public ActionResult DeleteConfirmed(int id)
{
Campsite campsite = db.Campsites.Find(id);
db.Campsites.Remove(campsite);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Iterate through each existing reservation and feed to base case comparison methods.
/// If the new reservation will not fit with one existing reservation, returns false.
/// </summary>
/// <param name="inputJson">Input test object.</param>
/// <param name="tmpCampSite">The current campsite we are trying to insert the new reservation into.</param>
/// <returns>bool indicating if a new reservation will fit between all existing reservation for all given gap rules.</returns>
public bool CompareCampsiteReservations(JsonTemplate inputJson, Campsite tmpCampSite)
{
var canFit = true;
foreach (var res in tmpCampSite.CampsiteReservationList)
{
canFit = CompareInputRangeToReservationForEachGap(inputJson, res) && canFit;
}
return(canFit);
}
public ActionResult Edit([Bind(Include = "CampId,Description,Price,Type,Accomodates,Location")] Campsite campsite)
{
if (ModelState.IsValid)
{
db.Entry(campsite).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(campsite));
}
public ActionResult Create([Bind(Include = "CampId,Description,Price,Type,Accomodates,Location")] Campsite campsite)
{
if (ModelState.IsValid)
{
db.Campsites.Add(campsite);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(campsite));
}
public bool CanBePlacedOn(Campsite campsite, IItemOfInterest targetObject, Vector3 point, Vector3 normal, ref string errorMessage)
{
if (Vector3.Dot(normal, Vector3.down) < Orientation)
{
if (targetObject.IOIType == ItemOfInterestType.Scenery && targetObject.gameObject.CompareTag(Globals.TagGroundTerrain))
{
return(true);
}
}
return(false);
}
public void GetCampSiteAvailability_TotalCost_Test()
{
List <Campsite> output = s.GetCampsitesByAvailability(connectionString, cg, fromDate, toDate);
List <Campsite> output2 = s.GetCampsitesByAvailability(connectionString, cg2, fromDate, toDate);
Campsite cs = output[0];
Campsite cs2 = output2[0];
decimal result = s.CalculateCostOfReservation(cs, fromDate, toDate, connectionString);
decimal result2 = s.CalculateCostOfReservation(cs2, fromDate, toDate, connectionString);
Assert.AreEqual(140.00m, Decimal.Round(result, 2));
Assert.AreEqual(100.00m, Decimal.Round(result2, 2));
}
// GET: Campsites/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Campsite campsite = db.Campsites.Find(id);
if (campsite == null)
{
return(HttpNotFound());
}
return(View(campsite));
}
public void CanCreateOnlyUniqueCampsites(int id, string name, bool canCreate)
{
// Setup
var campsite = new Campsite()
{
Id = id,
Name = name,
};
// Test
var success = service.CreateCampsite(campsite);
// Assert
Assert.Equal(success, canCreate);
}
private void DisplayCampgroundSites(int campgroundId, DateTime arriveDate, DateTime departDate)
{
_campsites.Clear();
List <Campsite> campsites = _campsiteDAL.GetCampgroundSites(campgroundId, arriveDate, departDate);
for (int index = 0; index < campsites.Count; index++)
{
int numDays = (int)(_departureDate - _arrivalDate).TotalDays + 1;
decimal totalCost = CalculateCost(campgroundId, numDays);
Campsite campsite = campsites[index];
Console.WriteLine("{0, -10}{1, -20}{2, -20}{3, -20}{4, -20}{5, -20}", campsite.SiteNumber, campsite.MaxOccupancy, campsite.MaxRvLengthStr, campsite.IsAccessibleStr, campsite.UtilitiesStr, totalCost.ToString("c"));
_campsites.Add(index + 1, campsite);
}
}
public static void add(Campsite campsite)
{
Database.getInstance().open();
SqlCommand query = new SqlCommand(ADD_SQL, Database.getInstance().getConnection());
query.Parameters.AddWithValue("numero", campsite.Numero);
query.Parameters.AddWithValue("zone", campsite.Zone);
query.Parameters.AddWithValue("category", campsite.Category);
query.Parameters.AddWithValue("nbPersonne", campsite.NbPersonne);
query.Parameters.AddWithValue("prize", campsite.Prize);
query.Parameters.AddWithValue("isReserved", campsite.IsReserved);
query.Parameters.AddWithValue("isUnavailable", campsite.IsUnavailable);
query.ExecuteNonQuery();
Database.getInstance().close();
}
/// <summary>
/// Add a list of reservations to each campsite.
/// This makes it easier to keep track of campsites when traversing through reservations.
/// </summary>
/// <param name="inputJson">input test object.</param>
private void BuildCampsiteReservationList(JsonTemplate inputJson)
{
foreach (var res in inputJson.Reservations)
{
try
{
Campsite tmpCampSite = inputJson.Campsites.Where(x => x.Id == res.CampsiteId).First();
tmpCampSite.CampsiteReservationList.Add(res);
}
catch (Exception ex)
{
//couldn't find that campsite ID in our list of campsites
throw new Exception("Invalid Campsite ID provided with reservation. " + ex.Message);
}
}
}
public void CampsiteDisplayTest()
{
Campsite myCampsite = new Campsite();
myCampsite.SiteId = 1;
myCampsite.CampgroundId = 1;
myCampsite.SiteNumber = 2;
myCampsite.MaxOccupancy = 6;
myCampsite.Accessible = "Y";
myCampsite.MaxRVLength = 30;
myCampsite.Utilities = "Y";
myCampsite.ParkId = 1;
myCampsite.ParkName = "Glacier";
myCampsite.CampgroundName = "Running Brook";
myCampsite.DailyFee = 35.00M;
//Console.WriteLine(myCampsite.ToString());
//Console.ReadKey();
}
public int sitespots(Campsite campsite)
{
int sites = 0;
Db db = new Db();
SqlConnection conn = openconn();
String sql = "SELECT AdvanceSite FROM [PermitDB].[dbo].[Campsites] where CampsiteId=@campsiteid";
SqlCommand cmd = new SqlCommand(sql, conn);
cmd.Parameters.AddWithValue("@campsiteId", campsite.CampsiteId);
SqlDataReader rdr = cmd.ExecuteReader();
if (rdr.Read())
{
sites = Convert.ToInt32(rdr["AdvanceSite"]);
}
rdr.Close();
db.closeconn(conn);
return(sites);
}
public Campsite getcampsite(int nightid)
{
Db db = new Db();
Campsite campsite = null;
SqlConnection conn = openconn();
String sql = "SELECT * FROM Campsites where campsiteId=@nightid";
SqlCommand cmd = new SqlCommand(sql, conn);
cmd.Parameters.AddWithValue("@nightid", nightid);
SqlDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
campsite = new Campsite(Convert.ToInt32(rdr["CampsiteId"]), rdr["Name"].ToString(), Convert.ToDateTime(rdr["OpenDate"]), Convert.ToDateTime(rdr["CloseDate"]), Convert.ToInt32(rdr["TotalSite"]), Convert.ToInt32(rdr["AdvanceSite"]), Convert.ToInt32(rdr["Stock"]), Convert.ToInt32(rdr["Tents"]), Convert.ToInt32(rdr["GroupSize"]));
}
rdr.Close();
db.closeconn(conn);
return(campsite);
}
void ReadCSVFile()
{
//from Resources folder load data
TextAsset Campsite_data = Resources.Load <TextAsset>(data_name);
//string[] data = Campsite_data.text.Split(new string[] { "!!!!"+'"'},StringSplitOptions.RemoveEmptyEntries);//split for each line…...
string[] data = Campsite_data.text.Split(new char[] { '\n' });
TextAsset excerpt_data = Resources.Load <TextAsset>("excerpt");
string[] excerpt = excerpt_data.text.Split(new string[] { "!!!!" + '"' }, StringSplitOptions.RemoveEmptyEntries);//split for each line…...
/*StreamReader inp_stm = new StreamReader("Assets/Resorces/data.csv");
* while (!inp_stm.EndOfStream)
* {
* string inp_ln = inp_stm.ReadLine();
*
* stringList.Add(inp_ln);
* }
*
* inp_stm.Close();
*
* parseList();*/
Debug.Log(excerpt[2]);
for (int i = 0; i < data.Length - 1; i++)//when there is no header i=0
{
Campsite campsite = new Campsite();
string[] row = data[i].Split(new char[] { ',' }, 4);
//string[] row = stringList[i].Split(new char[] { ',' });
campsite.lat = row[0];
campsite.lng = row[1];
float.TryParse(row[2], out campsite.rating);
Campsites.Add(campsite);
//Debug.Log('1');
}
for (int i = 0; i < excerpt.Length - 1; i++)//when there is no header i=0
{
Campsite campsite = Campsites[i];
campsite.excerpt = excerpt[i];
//Debug.Log(campsite.excerpt);
}
}
public static Campsite get(int id)
{
Campsite campsite = null;
Database.getInstance().open();
SqlCommand query = new SqlCommand(GET_SQL, Database.getInstance().getConnection());
query.Parameters.AddWithValue("id", id);
SqlDataReader reader = query.ExecuteReader();
if (reader.Read())
{
campsite = new Campsite((int)reader["campsite_id"], (int)reader["campsite_numero"], reader["campsite_zone"].ToString(), reader["campsite_category"].ToString(), (int)reader["campsite_nbPersonne"], (Decimal)reader["campsite_prize"], (bool)reader["campsite_isReserved"], (bool)reader["campsite_isUnavailable"]);
}
reader.Close();
Database.getInstance().close();
return(campsite);
}
public bool CreateCampsite(Campsite campsite)
{
return(campsites.Add(campsite));
}
public void SearchCampgroundReservations(string park, string campground)
{
List <Campsite> avaiablereservations = new List <Campsite>();
bool validInput = false;
DateTime arrivalDate = DateTime.MinValue;
DateTime departureDate = DateTime.MinValue;
bool SearchReservations = true;
do
{
do
{
Console.Write("What is the arrival date? (mm/dd/yyyy): ");
string input = Console.ReadLine();
try
{
arrivalDate = DateTime.Parse(input);
validInput = true;
}
catch
{
Console.WriteLine("Invalid Input (mm/dd/yyyy): ");
}
} while (validInput == false);
validInput = false;
do
{
Console.Write("What is the departure date? (mm/dd/yyyy): ");
string input = Console.ReadLine();
try
{
departureDate = DateTime.Parse(input);
validInput = true;
}
catch
{
Console.WriteLine("Invalid Input (mm/dd/yyyy): ");
}
} while (validInput == false);
ReservationSqlDAL reservationSqlDAL = new ReservationSqlDAL();
avaiablereservations = reservationSqlDAL.SearchForReservation(park, campground, arrivalDate, departureDate);
if (avaiablereservations.Count == 0)
{
Console.WriteLine("No available sites\n");
validInput = false;
do
{
try
{
Console.Write("Would you like to enter another date (Y/N): ");
char anotherSearch;
anotherSearch = Convert.ToChar(Console.ReadLine());
if (char.ToUpper(anotherSearch) == 'Y')
{
validInput = true;
SearchReservations = true;
}
else if (char.ToUpper(anotherSearch) == 'N')
{
validInput = true;
SearchReservations = false;
return;
}
}
catch
{
Console.WriteLine("\nPlease Enter (Y/N)");
}
} while (validInput == false);
}
else
{
SearchReservations = false;
}
} while (SearchReservations == true);
Console.WriteLine("\nResults Matching Your Search Criteria");
Console.WriteLine("Site No.".PadRight(11) + "Max Occup.".PadRight(11) + "Accessible".PadRight(13) + "Max RV Length".PadRight(15) + "Utility".PadRight(9) + "Cost");
foreach (Campsite campsite in avaiablereservations)
{
TimeSpan difference = departureDate - arrivalDate;
Console.WriteLine(
Convert.ToString(campsite.SiteNumber).PadRight(11) +
Convert.ToString(campsite.MaxOccupancy).PadRight(11) +
Convert.ToString(campsite.Accessible).PadRight(13) +
Convert.ToString(campsite.MaxRvLength).PadRight(15) +
Convert.ToString(campsite.Utilities).PadRight(9) +
(campsite.DailyFee * (difference.Days + 1)).ToString("C2")
);
}
validInput = false;
Campsite selectedCampsite = new Campsite();
Console.WriteLine("");
do
{
int userinput = 0;
try
{
Console.Write("Which site should be reserved (enter 0 to cancel): ");
userinput = int.Parse(Console.ReadLine());
if (userinput == 0)
{
return;
}
foreach (Campsite campsite in avaiablereservations)
{
if (campsite.SiteNumber == userinput)
{
validInput = true;
selectedCampsite = campsite;
}
}
if (validInput == false)
{
Console.WriteLine("Invalid Site Number\n");
}
}
catch (FormatException e)
{
Console.WriteLine("Invalid Input\n");
}
} while (validInput == false);
Console.Write("What name should the reservation be made under): ");
string name = Console.ReadLine();
MakeNewReservation(name, selectedCampsite.SiteId, arrivalDate, departureDate);
Console.WriteLine("");
}
/// <summary>
/// Collects the site to reserve
/// </summary>
private int GetCampsiteID()
{
Console.WriteLine();
Console.Write("Which site should be reserved (enter 0 to cancel)? ");
int? desiredCampsite = null;
string temporaryDesiredCampsite = "";
Campsite chosenSite = null;
// Generate exception to catch invalid input and prompt user to stop being ridiculous
Exception invalidInput = new Exception();
// Repeat as long as we have not received a response that represents a campsite
while (chosenSite == null)
{
temporaryDesiredCampsite = Console.ReadLine();
try
{
// If user has entered a non-integer character, we cannot use it to find a campsite,
// So we throw an exception
if (!Regex.IsMatch(temporaryDesiredCampsite, @"^[0-9]+$"))
{
// throw and catch
throw invalidInput;
}
else
{
// If user has entered a character representing an integer,
// We parse it as our desired campsite selection
desiredCampsite = int.Parse(temporaryDesiredCampsite);
if (desiredCampsite == 0)
{
Console.WriteLine();
Console.WriteLine("Returning to previous menu...");
Thread.Sleep(1000);
Console.Clear();
GetCampgroundsByPark();
// This lets us close the method if user selects 0
return((int)desiredCampsite);
}
// We check through campsite numbers to find a hit
for (int i = 0; i < campsites.Count; i++)
{
if (desiredCampsite == campsites[i].SiteNumber)
{
// If a hit is found, we use that campsite as our selection
chosenSite = campsites[i];
break;
}
// We check the next campsite if a hit is not found
else
{
continue;
}
}
// If there are no hits in list, we throw an exception and re-loop process
if (chosenSite == null)
{
throw invalidInput;
}
}
}
catch (Exception)
{
Console.WriteLine("Invalid site selected. Please select a valid site.");
Thread.Sleep(1000);
ClearCurrentConsoleLine();
ClearCurrentConsoleLine();
Console.Write("Which site should be reserved (enter 0 to cancel)? ");
}
}
// Return ID of selected campsite
return(chosenSite.SiteID);
}
public void OnEquipCampsite(Campsite activeCampsite)
{
AvailableWaterSources.Clear();
ActiveCampsite = activeCampsite;
enabled = true;
}
private static void CreateReservationMenu(string selectedCampground, List <Campground> campgrounds,
Campground campground, DateTime arrival, DateTime departure,
string connectionString)
{
PrintMenuDoubleSpaced(new[] { campground.Name + " Campground" });
PrintTrees();
Console.WriteLine();
List <Campsite> availableCampsites = campsiteDAL.GetCampsitesByAvailability(connectionString, campground, arrival, departure);
if (availableCampsites.Count == 0)
{
Console.Clear();
PrintMenuDoubleSpaced(new[] { "I'm sorry, there are no available dates for your selected visit, please select again..." });
CheckReservationAvailabilityMenu(campgrounds, selectedCampground);
}
Console.SetCursorPosition((Console.WindowWidth - 80) / 2, Console.CursorTop);
Console.WriteLine("{0, -15}{1, -15}{2, -15}{3, -15}{4, -15}{5, -15}", $"Site No.", $"Max Occup.", $"Accessible?", $"Max RV Length", $"Utility", $"Cost");
Console.WriteLine();
foreach (var site in availableCampsites)
{
decimal totalCost = campsiteDAL.CalculateCostOfReservation(site, arrival, departure, connectionString);
Console.SetCursorPosition((Console.WindowWidth - 80) / 2, Console.CursorTop);
Console.WriteLine("{0, -15}{1, -15}{2, -15}{3, -15}{4, -15}{5, -15}", $"{site.SiteID}", $"{site.MaxOccupancy}", $"{site.Accessible}", $"{site.MaxRvLength}", $"{site.Utilities}", $"{totalCost.ToString("c")}");
}
Console.WriteLine();
Campsite reservationSite = new Campsite();//create a new campsite so that the user can book their stay
PrintTreesBottom();
int userSelectedSiteID = CLIHelper.GetInteger("What site should be reserved?(To Return to the Main Menu press (0))");
//first verify that the site_id entered exists from the list provided to the user only!
bool exists = availableCampsites.Any(x => x.SiteID == userSelectedSiteID);
if (userSelectedSiteID == 0)
{
Console.Clear();
MainMenu();
}
else if (exists)
{
reservationSite.SiteID = userSelectedSiteID;
//book a reservation based on the site_id
}
else
{
Console.Clear();
Console.WriteLine("That is not a valid option, please select from the choices below...");
CreateReservationMenu(selectedCampground, campgrounds, campground, arrival, departure, connectionString);
}
string nameOfReservation = CLIHelper.GetString("What name should the reservation be placed under?");
if (availableCampsites.Any(x => x.SiteID == userSelectedSiteID))
{
campsiteDAL.CreateReservation(reservationSite.SiteID, arrival, departure, nameOfReservation, connectionString);
Console.WriteLine($"The reservation has been created and the reservation id is " +
$"{campsiteDAL.GetReservationID(reservationSite.SiteID, connectionString)}");
Console.WriteLine("Press Enter to Return to the Main Menu");
Console.ReadLine();
MainMenu();
}
else
{
// if the site has not been reserved on the provided dates the reservation will be created
Console.WriteLine("This site is already reserved during the dates provided");
CheckReservationAvailabilityMenu(campgrounds, selectedCampground);
}
}
