public async Task <ActionResult <ReservationItem> > PostReservationItem(ReservationItem item)
{
_context.ReservationItems.Add(item);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetReservationItem), new { id = item.Id }, item));
}
/// <summary>
/// Manages the reservation workflow for the entire park
/// </summary>
/// <param name="park">The park information the reservtion is for</param>
private void DisplayParkWideReservation(ParkItem park)
{
ReservationInfo reservationInfo = new ReservationInfo();
List <SiteInfo> siteInfos = new List <SiteInfo>();
try
{
reservationInfo = GetReservationInfo(reservationInfo);
var campgrounds = _db.GetCampgrounds(park.Id);
foreach (var campground in campgrounds)
{
reservationInfo.CampgroundId = campground.Id;
var sites = _db.GetSites(reservationInfo);
foreach (var site in sites)
{
siteInfos.Add(site.CreateSiteInfo(campground.DailyFee, campground.Name));
}
}
ReservationItem item = new ReservationItem();
item.SiteId = GetSiteSelection(siteInfos, reservationInfo, "", true);
DisplayCompleteReservation(reservationInfo, item);
throw new ExitToMainException();
}
catch (ExitException)
{
// do nothing, the user cancelled the reservation process
}
}
public void Create(ReservationItem newReservationItem)
{
var entry = db.Add(newReservationItem);
entry.State = EntityState.Added;
db.SaveChanges();
}
public void Edit(ReservationItem editedReservationItem)
{
var entry = db.Attach(editedReservationItem);
entry.State = EntityState.Modified;
db.SaveChanges();
}
public void Delete(int reservationItemToRemoveReservationId, int reservationItemToRemoveItemId)
{
ReservationItem toDelete = Get(reservationItemToRemoveReservationId, reservationItemToRemoveItemId);
var entry = db.Remove(toDelete);
entry.State = EntityState.Deleted;
db.SaveChanges();
}
public async Task <bool> PostReservation(ReservationItem reservationItem)
{
if (reservationItem.Id == null)
{
return(false);
}
return(await ReservationService(reservationItem.Id).AddAsync(reservationItem));
}
public void CanCreateCheck()
{
LogIn(1301);
// in the past
DateTime sd = DateTime.Parse("2017-01-17 08:00:00");
DateTime ed = DateTime.Parse("2017-01-17 08:30:00");
TimeSpan duration = ed - sd;
var rsv = new ReservationItem()
{
ResourceID = 41010,
ClientID = 1301,
AccountID = 67,
ActivityID = 6,
BeginDateTime = sd,
EndDateTime = ed,
ApplyLateChargePenalty = true,
AutoEnd = false,
ChargeMultiplier = 1,
CreatedOn = DateTime.Now,
LastModifiedOn = DateTime.Now,
Duration = duration.TotalMinutes,
HasInvitees = false,
HasProcessInfo = false,
IsActive = true,
IsStarted = false,
KeepAlive = false,
IsUnloaded = false,
MaxReservedDuration = duration.TotalMinutes,
Notes = string.Empty
};
var mgr = ServiceProvider.Current.Use <IReservationManager>();
try
{
mgr.CanCreateCheck(rsv);
}
catch (Exception ex)
{
Assert.AreEqual("Your reservation was not created. Cannot create a reservation in the past.", ex.Message);
}
// end before begin
rsv.BeginDateTime = DateTime.Now.Date.AddDays(1).AddHours(8); //tomorrow at 8 am
rsv.EndDateTime = rsv.BeginDateTime.AddMinutes(-15); //tomorrow at 7:45 am
try
{
mgr.CanCreateCheck(rsv);
}
catch (Exception ex)
{
Assert.AreEqual("Your reservation was not created. Cannot create a reservation that ends before it starts.", ex.Message);
}
}
public void Delete(int reservationItemToRemoveReservationId, int reservationItemToRemoveItemId)
{
ReservationItem toDelete = Get(reservationItemToRemoveReservationId, reservationItemToRemoveItemId);
if (toDelete != null)
{
ReservationItems.Remove(toDelete);
}
}
public static ReservationItemDTO ConvertReservationItem(ReservationItem item)
{
return(new ReservationItemDTO()
{
ID = item.ID,
ItemName = item.ItemName,
QuantityOrdered = item.QuantityOrdered,
RemainingUnreserved = item.RemainingUnreserved
});
}
public ReservationItemDetail(IItemData itemData, IReservationItemData reservationItemData, int reservationId, int itemId)
{
ReservationItem reservationItem = reservationItemData.Get(reservationId, itemId);
ReservationId = reservationId;
ItemId = itemId;
Name = itemData.Get(itemId).Name;
Amount = reservationItem.Amount;
Price = reservationItem.Price;
}
protected void btnSave_Click(object sender, EventArgs e)
{
Page.Validate("vgPrimaryAdd");
if(Page.IsValid)
{
Reservation r = new Reservation();
r.UserId = Guid.Parse(Membership.GetUser().ProviderUserKey.ToString());
r.SubjectId = Convert.ToInt32(ddlSubject.SelectedValue);
r.ExperimentNo = txtExpNo.Text;
r.DateRequested = DateTime.Now;
r.DateFrom = Convert.ToDateTime(txtDateNeeded.Text);
r.DateTo = Convert.ToDateTime(txtDateNeededTo.Text);
r.LabRoom = txtLabRoom.Text;
r.ApprovalStatus = "Pending";
r.IsReleased = false;
r.IsReturned = false;
db.Reservations.InsertOnSubmit(r);
db.SubmitChanges();
int reserveId = r.Id;
gvInv.AllowPaging = false;
gvInv.DataBind();
//reserve selected items
foreach (GridViewRow row in gvInv.Rows)
{
string quantity = "";
string quantityByGroup = "";
int invId = Convert.ToInt32(((Label)row.FindControl("lblRowId")).Text);
if (
(quantity = ((TextBox)row.FindControl("txtQuantityToBorrow")).Text) != String.Empty &&
(quantityByGroup = ((TextBox)row.FindControl("txtQuantityToBorrowByGroup")).Text) != String.Empty
)
{
ReservationItem ri = new ReservationItem();
ri.InventoryId = invId;
ri.Quantity = Convert.ToInt32(quantity);
ri.ReservationId = reserveId;
ri.QuantityByGroup = Convert.ToInt32(quantityByGroup);
db.ReservationItems.InsertOnSubmit(ri);
db.SubmitChanges();
}
}
gvInv.AllowPaging = true;
gvInv.DataBind();
Response.Redirect("~/reserve/default.aspx");
}
}
public void Edit(ReservationItem editedReservationItem)
{
for (int i = 0; i < ReservationItems.Count; i++)
{
if (ReservationItems[i].ReservationId == editedReservationItem.ReservationId && ReservationItems[i].ItemId == editedReservationItem.ItemId)
{
ReservationItems[i] = editedReservationItem;
return;
}
}
}
/// <summary>
/// Displays park / campground / site availability
/// </summary>
private void DisplayEntireParkAvailability()
{
List <CampgroundItem> campgrounds = _db.GetCampgroundItemsByPark(_selectedPark.Id);
(DateTime FromDate, DateTime ToDate) = CLIHelper.GetValidReservationWindow();
Console.Clear();
foreach (var campground in campgrounds)
{
Console.WriteLine(campground.Id + ") " + campground.Name);
Console.WriteLine();
DisplaySiteDetail(campground.Id, _db.GetAvailableSiteItems(campground.Id, FromDate, ToDate));
Console.WriteLine("-------------------------------------------------------------------------");
}
// make a campground selection
int selectedCampground = SelectCampground(campgrounds);
if (selectedCampground != 0)
{
List <SiteItem> selectedSites = _db.GetAvailableSiteItems(selectedCampground, FromDate, ToDate);
int siteSelection = SelectSite(selectedSites);
if (siteSelection != 0)
{
if (siteSelection != 0)
{
string reservationName = CLIHelper.GetString("What name should the reservation be made under? ");
ReservationItem reservation = new ReservationItem();
reservation.SiteId = siteSelection;
reservation.Name = reservationName;
reservation.FromDate = FromDate;
reservation.ToDate = ToDate;
reservation.CreateDate = DateTime.Now;
int userId = _userMgr.User.Id;
int reservationId = -1;
try
{
reservationId = _db.MakeReservation(reservation, userId);
SuccessFulReservation(reservationName, reservationId);
}
catch (Exception)
{
Console.WriteLine("There was an error in your request, returning to previous screen.");
}
}
}
}
}
public void FromSeatToItemRequest_CorrectlyMapped()
{
var seat = new ReservationItem
{
AggregateReference = "reference",
AreaName = "E",
};
var result = seat.Map <ReservationItem, ReservationItemParameters>();
result.ShouldBeEquivalentToObjectWithMoreProperties(seat);
}
public async Task <bool> TryAddReservationToShowAsync(ReservationItem reservation)
{
var show = await GetByIdAsync(reservation.ShowItemId);
if (IsInvalidShow(reservation, show))
{
return(false);
}
show.Reservations.TryAdd(reservation.Id, reservation);
return(await _showRepository.UpdateAsync(show.Id, show));
}
private ReservationItem GetReservationItemFromReader(SqlDataReader reader)
{
ReservationItem item = new ReservationItem();
item.Id = Convert.ToInt32(reader["reservation_id"]);
item.SiteId = Convert.ToInt32(reader["site_id"]);
item.Name = Convert.ToString(reader["name"]);
item.FromDate = Convert.ToDateTime(reader["from_date"]);
item.ToDate = Convert.ToDateTime(reader["to_date"]);
item.CreateDate = Convert.ToDateTime(reader["create_date"]);
return(item);
}
/// <summary>
/// Creates a reservation in the reservation table and associates it with a user
/// </summary>
/// <param name="item">The reservation item to be saved</param>
/// <param name="userId">The id of the user to associate with the reservation</param>
/// <returns>The autogenerated primary key for the reservation</returns>
public int MakeReservation(ReservationItem reservation, int userId)
{
int reservationId = BaseItem.InvalidId;
using (TransactionScope scope = new TransactionScope())
{
reservationId = AddReservation(reservation);
AddUserReservation(reservationId, userId);
scope.Complete();
}
return(reservationId);
}
public async Task <bool> TryRemoveReservationFromShowAsync(ReservationItem item)
{
var show = await GetByIdAsync(item.ShowItemId);
if (show.Reservations.ContainsKey(item.Id))
{
if (show.Reservations.TryRemove(item.Id, out _))
{
return(await _showRepository.UpdateAsync(show.Id, show));
}
}
return(false);
}
/// <summary>
/// Creates a reservation database object
/// </summary>
/// <param name="site">The site to be reserved</param>
/// <param name="fromDate">The start date of the reservation</param>
/// <param name="toDate">The end date of the reservation</param>
/// <returns>A complete reservation database object</returns>
private ReservationItem CreateReservation(SiteItem site, DateTime fromDate, DateTime toDate)
{
var reservation = new ReservationItem()
{
SiteId = site.Id,
CreatedDate = DateTime.UtcNow,
FromDate = fromDate,
ToDate = toDate,
Name = "Jones"
};
return(reservation);
}
public async Task <IHttpActionResult> CreateReservation(string showId)
{
var reservation = new ReservationItem
{
ShowItemId = new ItemId(new Guid(showId))
};
var id = reservation.Id;
if (await ReservationService(id).AddAsync(reservation))
{
return(Ok(id));
}
return(BadRequest());
}
/// <summary>
/// Displays the reservation info to the user
/// </summary>
/// <param name="reservation">The reservation info used to filter the campsite selection options</param>
/// <param name="item">The reservation details</param>
private void DisplayCompleteReservation(ReservationInfo reservation, ReservationItem item)
{
item.Name = CLIHelper.GetString("What name should the reservation be made under?");
item.FromDate = reservation.FromDate;
item.ToDate = reservation.ToDate;
item.CreatedDate = DateTime.UtcNow;
var confirmationId = _db.MakeReservation(item, _userMgr.User.Id);
Console.WriteLine();
Console.WriteLine($"The reservation has been made and the confirmation id is {confirmationId}");
Console.WriteLine(Message_PressKeyContinue);
Console.ReadKey();
}
public void InitializeReservation()
{
_db = new ParkDAO("Data Source=localhost\\sqlexpress;Initial Catalog=npcampground;Integrated Security=True");
_tran = new TransactionScope();
ReservationItem item = new ReservationItem()
{
SiteId = TEST_SITE_ID,
Name = "Henry Family Vacation",
FromDate = DateTime.Parse("2019/07/22"),
ToDate = DateTime.Parse("2019/07/29"),
CreateDate = DateTime.Parse("2019/06/25"),
};
_reservation_id = _db.AddReservationItem(item);
}
public async Task <ActionResult <ReservationItem> > Approve([FromBody] ReservationItem reservation)
{
var stored = await Context.Reservations
.SingleOrDefaultAsync(r => r.Id == reservation.Id);
if (stored == null)
{
return(BadRequest("No reservation with that Id."));
}
else
{
stored.Status = ReservationStatus.Approved;
await Context.SaveChangesAsync();
return(NoContent()); // Fine.
}
}
/// <summary>
/// 最新予約取得を実行する
/// </summary>
/// <returns></returns>
public CheckReservationResult Execute()
{
var ret = default(CheckReservationResult);
// ドライバ初期化
using (var driver = WebDriverFactory.CreateInstance(AppSettings.BrowserName.Chrome))
{
// アクセス
driver.Url = String.Format("{0}mypage/reservation/?lcl_id=ja", SiteConfig.BASE_URL);
// ログイン試行
if (!TryLogin(driver))
{
// ログイン失敗
ret = CheckReservationResult.LoginFailed;
_reservationItem = null;
}
else
{
try
{
// ホテル名
string name = driver.FindElement(By.XPath(SiteConfig.XPATH_RESERVATION_NAME)).Text;
// チェックイン日時
string date = driver.FindElement(By.XPath(SiteConfig.XPATH_RESERVATION_DATE)).Text.Split(new string[] { "\r\n" }, StringSplitOptions.None)[0];
// 予約あり
ret = CheckReservationResult.Found;
_reservationItem = new ReservationItem()
{
Name = name,
Date = date
};
}
catch (NoSuchElementException)
{
// 予約なし
ret = CheckReservationResult.NotFound;
_reservationItem = null;
}
}
}
return(ret);
}
public async Task <IEnumerable <ReservationItem> > CreateAsync(ReservationItem reservation)
{
using (var conn = await GetOpenConnectionAsync())
{
return(await conn.QueryAsync <ReservationItem>(
param : new {
Id = reservation.Id,
ClientId = reservation.ClientId,
CarId = reservation.CarId,
RentalStartDate = reservation.RentalStartDate,
RentalEndDate = reservation.RentalEndDate,
PickUpLocation = reservation.PickUpLocation,
DropOffLocation = reservation.DropOffLocation,
TotalPrice = reservation.TotalPrice
},
sql : SpCreate,
commandType : CommandType.StoredProcedure));
}
}
/// <summary>
/// Adds a row to the reservation table
/// </summary>
/// <param name="item">The reservation item containing the data to add</param>
/// <returns>The autogenerated primary key</returns>
private int AddReservation(ReservationItem item)
{
const string sql = "INSERT [reservation] (site_id, name, from_date, to_date, create_date) " +
"VALUES (@SiteId, @Name, @FromDate, @ToDate, @CreateDate);";
using (SqlConnection conn = new SqlConnection(_connectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand(sql + _getLastIdSQL, conn);
cmd.Parameters.AddWithValue("@SiteId", item.SiteId);
cmd.Parameters.AddWithValue("@Name", item.Name);
cmd.Parameters.AddWithValue("@FromDate", item.FromDate);
cmd.Parameters.AddWithValue("@ToDate", item.ToDate);
cmd.Parameters.AddWithValue("@CreateDate", item.CreatedDate);
item.Id = (int)cmd.ExecuteScalar();
}
return(item.Id);
}
private IList <ReservationItem> ConvertToReservationItem(IDictionary <int, Reservation> reservations)
{
IList <ReservationItem> reservationItems = new List <ReservationItem>();
foreach (Reservation reservation in reservations.Values)
{
ReservationItem reservationItem = new ReservationItem()
{
From = reservation.From,
To = reservation.To,
Id = reservation.Id,
LectureHallNumber = reservation.Hall.Number,
Lecturer = $"{reservation.Lecturer.Title} {reservation.Lecturer.Name} {reservation.Lecturer.Surname}"
};
reservationItems.Add(reservationItem);
}
return(reservationItems);
}
public TimeReservationContentViewModel(IInteractionRequestAware viewModel, ReservationItem item)
{
_reservationService = ServiceLocator.Current.GetInstance <ReservationService>();
StartAt = new ReactiveProperty <string>(item?.StartAt?.ToString() ?? "").AddTo(this);
RepetitionType = new ReactiveProperty <EnumWrap <Repetition> >(new EnumWrap <Repetition>(Repetition.None)).AddTo(this);
StartAt.SetValidateNotifyError(w => _dtValidator.Validate(w)).AddTo(this);
RegisterCommand = StartAt.ObserveHasErrors.Select(w => !w).ToReactiveCommand().AddTo(this);
RegisterCommand.Subscribe(w =>
{
if (item == null)
{
_reservationService.InsertTimeReservaion(DateTime.Parse(StartAt.Value),
RepetitionType.Value.EnumValue);
}
else
{
item.TimeReservation.StartAt = DateTime.Parse(StartAt.Value);
item.Update();
}
viewModel.FinishInteraction.Invoke();
}).AddTo(this);
}
/// <summary>
/// Prompts user to select a campsite then displays the completed reservation info
/// </summary>
/// <param name="reservation">Information about the reservation filters</param>
/// <param name="dailyFee">The daily fee for the campground for the sites being reserved</param>
/// <param name="campgroundName">The name of the campground the sites belong to</param>
private void DisplayCampsiteSelection(ReservationInfo reservation, decimal dailyFee, string campgroundName)
{
var sites = _db.GetSites(reservation);
if (sites.Count > 0)
{
var siteInfos = new List <SiteInfo>();
foreach (var site in sites)
{
siteInfos.Add(site.CreateSiteInfo(dailyFee, campgroundName));
}
Dictionary <string, SiteInfo> menu = new Dictionary <string, SiteInfo>();
ReservationItem item = new ReservationItem();
item.SiteId = GetSiteSelection(siteInfos, reservation, campgroundName);
DisplayCompleteReservation(reservation, item);
}
else
{
throw new NoAvailableCampsitesException();
}
}
/// <summary>
/// This Method Trys to Add the Reservation to the corresponding show
/// in the show service. If success -> Add the Reservation
/// </summary>
public async Task <bool> AddAsync(ReservationItem item)
{
if (item.ShowItemId == null) // ShowItemId is invalid
{
return(false);
}
if (!item.ReservationDateTime.HasValue) // DateTime missing
{
item.ReservationDateTime = DateTime.UtcNow;
}
bool isAddedOnShow =
await ShowService(item).TryAddReservationToShowAsync(item);
if (!isAddedOnShow) // show was not added to show
{
return(false);
}
return(await _reservationRepository.AddAsync(item));
}
public async Task <ActionResult <ReservationItem> > AddReservation([FromBody] PostReservationRequest item)
{
var reservation = new Reservation
{
For = item.For,
Books = item.Books,
Status = ReservationStatus.Pending
};
Context.Reservations.Add(reservation);
await Context.SaveChangesAsync();
var response = new ReservationItem
{
Id = reservation.Id,
For = reservation.For,
Books = reservation.Books,
Status = reservation.Status
};
// Write it to the Queue for the background worker (Coming Soon!) to process!
Queue.SendReservation(response);
return(Ok(response));
}
public CheckoutCompleteRoomInformationModel(ReservationItem reservationItem)
{
NameOfPrimaryGuest = reservationItem.NameOfPrimaryGuest;
Description = reservationItem.Description;
Adults = reservationItem.TotalNumberOfGuests;
TotalPrice = reservationItem.TotalPriceWithoutDiscount;
AddonsSummary = reservationItem.AddonsSummary;
RatesPerDay = reservationItem.PricePerDate.Select(x => new CheckoutCompleteRoomRatesPerDay(x));
}
//public CheckoutRoomInformationModel(ReservationItem reservationItem)
//{
// //Id = reservationItem.Id;
// NameOfPrimaryGuest = reservationItem.NameOfPrimaryGuest;
// ItemType = reservationItem.Description;
// Adults = reservationItem.TotalNumberOfGuests;
//}
public CheckoutRoomInformationModel(ReservationItem reservationItem, SearchResultRoom roomtype, IEnumerable<Addon> addons)
{
Id = Guid.NewGuid();
Addons = addons.Select(x =>
new CheckoutAddonItemModel(
x.Id,
x.Name.GetText(LanguageTypeEnum.English),
x.Description.GetText(LanguageTypeEnum.English),
x.Price,
x.PostingRhythm,
x.CalculationRule)
).ToList();
NameOfPrimaryGuest = reservationItem.NameOfPrimaryGuest;
ItemType = reservationItem.Description;
Adults = reservationItem.TotalNumberOfGuests;
Adults = (roomtype.MaxCapacity == 1) ? 1 : 0;
TotalPrice = roomtype.TotalPrice;
Guests = Enumerable.Range(1, roomtype.MaxCapacity).Select(x => new SelectListItem { Selected = (x == roomtype.MaxCapacity && x == 1), Text = x.ToString(), Value = x.ToString() }).ToList();
if (roomtype.MaxCapacity > 1)
{
Guests.Insert(0, new SelectListItem { Selected = false, Text = "0", Value = string.Empty });
}
}
