private void TestUpdateReservationToSingle(string reservationOrderId, string reservationId)
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var reservationsClient = ReservationsTestUtilities.GetAzureReservationAPIClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
var reservations = reservationsClient.Reservation.List(reservationOrderId);
var enumerator1 = reservations.GetEnumerator();
ReservationResponse validReservation = null;
while (enumerator1.MoveNext())
{
var currentReservation = enumerator1.Current;
if (String.Equals(currentReservation.Properties.ProvisioningState, "Succeeded"))
{
validReservation = currentReservation;
break;
}
}
Assert.NotNull(validReservation);
reservationId = validReservation.Id.Split('/')[6];
Patch Patch = new Patch(AppliedScopeType.Single, new List <string>()
{
$"/subscriptions/{Common.SubscriptionId}"
}, InstanceFlexibility.On);
var reservation = reservationsClient.Reservation.Update(reservationOrderId, reservationId, Patch);
ValidateReservation(reservation);
}
}
public static ReservationResponse ToApiModel(this Reservation model)
{
var temp = new ReservationResponse()
{
Id = model.Id,
Comment = model.Comment,
CreatedAt = model.CreatedAt,
StartAt = model.StartAt,
EndAt = model.EndAt,
IsEndless = model.IsEndless,
IsActive = model.IsActiveReservations(),
ModifiedAt = model.ModifiedAt,
Priority = model.Priority,
ObjectTag = new IdNamePair <string>()
{
Id = model.ObjectTagId, Name = model.ObjectTag.Name
},
Owner = new IdNamePair <string>()
{
Id = model.OwnerUser.UserName, Name = model.OwnerUser.DisplayName
},
Users = model.ReservationUsers.Select(c => new IdNamePair <string>()
{
Id = c.User.UserName, Name = c.User.DisplayName
}).ToList()
};
return(temp);
}
public async Task <ActionResult <ReservationResponse> > CreateAsync(ReservationRequest item)
{
var roomItem = await db.Rooms.FindAsync(item.RoomId);
if (roomItem == null)
{
return(NotFound(new ProblemDetails
{
Title = $"Room id {item.RoomId} not found"
}));
}
var hasOverlapped = db.Reservations.Where(q =>
q.RoomId == item.RoomId &&
!q.IsCanceled &&
q.CheckInDate <= item.CheckInDate &&
q.CheckOutDate >= item.CheckInDate
).Any();
if (hasOverlapped)
{
return(BadRequest(new ProblemDetails
{
Title = $"Reservation Duplicate"
}));
}
var newItem = item.ToModel();
await db.AddAsync(newItem);
await db.SaveChangesAsync();
return(CreatedAtAction(nameof(GetByIdAsync), new { id = item.Id }, ReservationResponse.FromModel(newItem)));
}
public ReservationDtocs UpdateReservation(ReservationResponse reservation)
{
ReservationDtocs clientExist = _reservationApp.GetReservationClietntId(reservation.IdClient);
if (clientExist == null)
{
new ReservationDtocs
{
MessageError = "Client is Required"
};
}
if (reservation.IdEvent == 0)
{
new ReservationDtocs
{
MessageError = "Category Event is Required"
};
}
ReservationDtocs newReserva = new ReservationDtocs
{
IdReservation = reservation.IdReservation,
DateDue = reservation.DateDue,
IdClient = reservation.IdClient,
IdEvent = reservation.IdEvent
};
ReservationDtocs response = _reservationApp.UpdateReservation(newReserva);
return(response);
}
public PSReservation(ReservationResponse Reservation)
{
if (Reservation != null)
{
Sku = Reservation.Sku.Name;
Location = Reservation.Location;
Etag = Reservation.Etag == null ? "" : Reservation.Etag.ToString();
Id = Reservation.Id;
Name = Reservation.Name;
Type = Reservation.Type;
ReservedResourceType = Reservation.Properties.ReservedResourceType;
InstanceFlexibility = Reservation.Properties.InstanceFlexibility;
DisplayName = Reservation.Properties.DisplayName;
AppliedScopes = Reservation.Properties.AppliedScopes;
AppliedScopeType = Reservation.Properties.AppliedScopeType;
Quantity = Reservation.Properties.Quantity == null ? "" : Reservation.Properties.Quantity.ToString();
ProvisioningState = Reservation.Properties.ProvisioningState;
EffectiveDateTime = Reservation.Properties.EffectiveDateTime;
LastUpdatedDateTime = Reservation.Properties.LastUpdatedDateTime;
ExpiryDate = Reservation.Properties.ExpiryDate;
SkuDescription = Reservation.Properties.SkuDescription;
ExtendedStatusInfo = Reservation.Properties.ExtendedStatusInfo;
SplitProperties = Reservation.Properties.SplitProperties;
MergeProperties = Reservation.Properties.MergeProperties;
}
}
private void TestUpdateRenewalProperties(string reservationOrderId, string reservationId)
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var reservationsClient = ReservationsTestUtilities.GetAzureReservationAPIClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
var reservations = reservationsClient.Reservation.List(reservationOrderId);
var enumerator1 = reservations.GetEnumerator();
ReservationResponse validReservation = null;
while (enumerator1.MoveNext())
{
var currentReservation = enumerator1.Current;
if (String.Equals(currentReservation.Properties.ProvisioningState, "Succeeded"))
{
validReservation = currentReservation;
break;
}
}
Assert.NotNull(validReservation);
reservationId = validReservation.Id.Split('/')[6];
var renewProperties = new PatchPropertiesRenewProperties()
{
PurchaseProperties = CreatePurchaseRequestBody()
};
Patch Patch = new Patch(renew: true, renewProperties: renewProperties);
var reservation = reservationsClient.Reservation.Update(reservationOrderId, reservationId, Patch);
var reservationWithRenewProperties = reservationsClient.Reservation.Get(reservationId, reservationOrderId, "renewProperties");
ValidateReservation(reservationWithRenewProperties);
Assert.True(reservationWithRenewProperties.Properties.Renew);
Assert.NotNull(reservationWithRenewProperties.Properties.RenewProperties);
}
}
public async Task <ActionResult <ReservationResponse> > GetByIdAsync(int id)
{
var item = await db.Reservations.FindAsync(id);
if (item == null)
{
return(NotFound(ErrUtil.CreateDetail($"Reservation id {id} not found")));
}
return(ReservationResponse.FromModel(item));
}
public ReservationDtocs AddReservation(ReservationResponse reservation)
{
var Finde = reservation.DateDue.DayOfWeek.Equals('5' & '6');
var hours = reservation.DateDue.ToString("HH:mm tt");
ReservationDtocs clientExist = _reservationApp.GetReservationClietntId(reservation.IdClient);
if (clientExist == null)
{
new ReservationDtocs
{
MessageError = "Client is Required"
};
}
ClientDto clientDto = _clientRepository.GetClienteId(reservation.IdClient);
if (clientDto.Age < 21 || clientDto.Status.Equals("Mora").Equals("Cancelado"))
{
new ReservationDtocs
{
MessageError = "Cliente no apto para reserva"
};
}
if (reservation.IdEvent == 0)
{
new ReservationDtocs
{
MessageError = "Category Event is Required"
};
}
if (reservation.DateDue.DayOfWeek.Equals('0'))
{
new ReservationDtocs
{
MessageError = "Not reservations on Sunday"
};
}
ReservationDtocs newReserva = new ReservationDtocs
{
IdReservation = reservation.IdReservation,
DateDue = reservation.DateDue,
IdClient = reservation.IdClient,
IdEvent = reservation.IdEvent
};
ReservationDtocs response = _reservationApp.AddReservation(newReserva);
return(response);
}
public static Reservation ConvertReservationResponseToReservation(ReservationResponse response)
{
Reservation res = new Reservation();
res.Email = response.userEmail;
res.Date = response.startDateTime.Date.ToString();
res.Time = response.startDateTime.TimeOfDay.ToString();
res.Directions = response.directionName;
return(res);
}
static void Main(string[] args)
{
// Open the config file and get the name for this branch
// and its network address
Configuration config = ConfigurationManager
.OpenExeConfiguration(ConfigurationUserLevel.None);
AppSettingsSection app =
(AppSettingsSection)config.GetSection("appSettings");
string adr = app.Settings["Address"].Value;
Console.WriteLine(app.Settings["Branch Name"].Value);
// Create a service to handle incoming requests
WorkflowService service = new WorkflowService
{
Name = "LibraryReservation",
Body = new ProcessRequest(),
Endpoints =
{
new Endpoint
{
ServiceContractName = "ILibraryReservation",
AddressUri = new Uri("http://localhost:" + adr + "/LibraryReservation"),
Binding = new BasicHttpBinding(),
}
}
};
// Create a WorkflowServiceHost that listens for incoming messages
System.ServiceModel.Activities.WorkflowServiceHost wsh = new System.ServiceModel.Activities.WorkflowServiceHost(service);
wsh.Open();
Console.WriteLine("Waiting for requests, press ENTER to send a request.");
Console.ReadLine();
// Create dictionary with input arguments for the workflow
IDictionary <string, object> input = new Dictionary <string, object>
{
{ "Title", "Gone with the Wind" },
{ "Author", "Margaret Mitchell" },
{ "ISBN", "9781416548898" }
};
// Invoke the SendRequest workflow
IDictionary <string, object> output = WorkflowInvoker.Invoke(new SendRequest(), input);
ReservationResponse resp = (ReservationResponse)output["Response"];
// Display the response
Console.WriteLine("Response received from the {0} branch", resp.Provider.BranchName);
Console.WriteLine();
Console.WriteLine("Press ENTER to exit");
Console.ReadLine();
// Close the WorkflowSe
}
public ReservationDtocs DeleteReservation(ReservationResponse reservation)
{
ReservationDtocs newReserva = new ReservationDtocs
{
IdReservation = reservation.IdReservation,
DateDue = reservation.DateDue,
IdClient = reservation.IdClient,
IdEvent = reservation.IdEvent
};
ReservationDtocs reservationDto = _reservationApp.DeleteReservation(newReserva);
return(reservationDto);
}
internal void ValidateReservation(ReservationResponse Reservation)
{
Assert.NotNull(Reservation);
Assert.NotNull(Reservation.Id);
Assert.NotNull(Reservation.Etag);
Assert.NotNull(Reservation.Name);
Assert.NotNull(Reservation.Properties);
Assert.NotNull(Reservation.Sku);
Assert.NotNull(Reservation.Type);
Assert.NotNull(Reservation.Properties.InstanceFlexibility);
Assert.NotNull(Reservation.Properties.ReservedResourceType);
Assert.NotNull(Reservation.Properties.SkuDescription);
}
public void RespondToRequest(ReservationResponse response)
{
Guid id = response.RequestID;
WorkflowApplication i = _outgoingRequests[id];
try
{
i.ResumeBookmark("GetResponse", response);
}
catch (Exception e2)
{
AddEvent(e2.Message);
}
}
public async Task <IActionResult> Post([FromBody] CreateReservationRequest request)
{
var reservation = new Reservation
{
FlightId = request.FlightId,
Flight = await _flightService.GetFlightByIdAsync(request.FlightId),
UserId = request.UserId,
User = await _userService.GetUserByIdAsync(request.UserId)
};
await _reservationService.CreateReservationAsync(reservation);
var url = String.Format(
"{0}://{1}{2}",
HttpContext.Request.Scheme,
HttpContext.Request.Host.ToUriComponent(),
ApiRoutes.Reservation.Get.Replace("{id}", reservation.Id.ToString())
);
var response = new ReservationResponse
{
Id = reservation.Id,
Flight = new FlightResponse
{
Id = reservation.Flight.Id,
Departure = reservation.Flight.Departure,
From = new CountryResponse
{
Id = reservation.Flight.From.Id,
Name = reservation.Flight.From.Name
},
To = new CountryResponse
{
Id = reservation.Flight.To.Id,
Name = reservation.Flight.To.Name
}
},
User = new UserResponse
{
Id = reservation.User.Id,
Name = reservation.User.Name,
TgUid = reservation.User.TgUid
}
};
return(Created(url, response));
}
/// <summary>
/// Function executed every time the timer is (12.00 AM)
/// </summary>
/// <param name="stateInfo"></param>
public void EnableRoom(Object stateInfo)
{
/*GroupNumber = 0;
* ZoneNumber = 0;*/
var client = new RestClient("http://140.118.123.95:5555");
var request = new RestRequest("smr/reservations/today", Method.GET);
Debug.WriteLine("GET TODAY's Information");
IRestResponse response = client.Execute(request);
if (response.IsSuccessful)
{
foreach (CrGroup crGroup in CrName.getCrGroupDb())
{
foreach (Person person in crGroup.People)
{
while (!GetConnected(crGroup.IP, crGroup.Port))
{
;
}
while (!RemovePerson(crGroup.Addr, person.CardNumber, crGroup.People.IndexOf(person) + 1))
{
;
}
}
}
CrName.clearCrGroup();
ReservationResponse resList = SimpleJson.DeserializeObject <ReservationResponse>(response.Content);
foreach (Reservation reservation in resList.Data)
{
while (!GetConnected(reservation.CardReader.IP, reservation.CardReader.Port))
{
;
}
if (CreateBooking(reservation))
{
Timer _countTimer = new Timer(CountTap, reservation, countTime(reservation.EndTime), Timeout.Infinite);
}
}
}
}
public void DeleteReservation(string noteId)
{
RestChannel channel = this._mainForm.GetChannel();
try
{
string strError = "";
List <ReservationItem> items = DbManager.Instance.GetItemsByNoteId(noteId);
foreach (ReservationItem item in items)
{
//this.AppendNewLine(this.listView_items, item);
ReservationResponse response = channel.Reservation("delete",
item.PatronBarcode,
item.ItemBarcode);
if (response.ReservationResult.ErrorCode != ErrorCode.NoError)
{
strError += response.ReservationResult.ErrorInfo + "\r\n";
}
// 更新一下本地库的预约记录状态，与服务器保持一致，
// 但界面还不会立即反应出来，需要点一下上方的备书单，再显示出来的详细信息就为outof状态了
item.State = "outof";
DbManager.Instance.UpdateItem(item);
}
if (strError != "")
{
// 用Invoke线程安全的方式来调
this.Invoke((Action)(() =>
{
MessageBox.Show(this, "调服务器取消预约出错:" + strError);
return;
}
));
}
}
finally
{
this._mainForm.ReturnChannel(channel);
}
}
public IHttpActionResult MakeReservation(ReservationRequest reservationRequest)
{
ReservationResponse reservationResponse = new ReservationResponse();
int passangerCount = reservationRequest.RezervasyonYapilacakKisiSayisi;
bool isFlexiable = reservationRequest.KisilerFarkliVagonlaraYerlestirilebilir;
foreach (var item in reservationRequest.Tren.Vagonlar)
{
if (passangerCount > 0)
{
reservationResponse.AddYerlesim(item.SetCustomerToVagon(ref passangerCount, true));
}
else
{
break;
}
}
reservationResponse.CheckReservationResponse(passangerCount > 0);
return(Ok(reservationResponse));
}
public async Task <List <Reservation> > GetUserActiveReservations(string path, string cip, CancellationToken token)
{
var now = DateTime.Now;
var response = new ReservationResponse();
response.directionName = "3IT";
response.endDateTime = now;
response.startDateTime = now;
if (Static.StaticValues.staticFacebookProfile != null)
{
response.userEmail = Static.StaticValues.staticFacebookProfile.Email;
}
List <Reservation> reservations = new List <Reservation>();
reservations.Add(NetworkResponseConverter.ConvertReservationResponseToReservation(response));
return(reservations);
}
public async Task <ActionResult <ReservationResponse> > DeleteAsync(int id, ReservationsDeleteRequest item)
{
if (id != item.Id)
{
return(BadRequest("Invalid ID"));
}
var itemReservation = await db.Reservations.FindAsync(id);
if (itemReservation == null)
{
return(NotFound(new ProblemDetails {
Title = $"Reservation id {id} not found"
}));
}
itemReservation.Cancel(item.CanceledDate, item.CancelReason);
db.SaveChanges();
return(ReservationResponse.FromModel(itemReservation));
}
public ReservationResponse makeRoomReservation(ReservationRequest request)
{
try
{
HotelFacade hotelFacade = new HotelFacade();
DateTime startDate = DateTime.Parse(request.StartDate);
Payment payment = new Payment();
payment.CardType = request.CardType;
payment.GuestAccount = request.GuestAccount;
payment.TotalCharge = request.TotalCharge;
payment.CardType = request.CardType;
String responseCode = hotelFacade.makeReservation(request.RoomNo, request.GuestName, request.GuestPassport, startDate, request.Duration, request.NumOfGuest, payment);
ReservationResponse response = new ReservationResponse();
response.responseCode = responseCode;
return(response);
}
catch (Exception e)
{
throw new FaultException <Exception>(e);
}
}
public List <ReservationDtocs> GetReservations(ReservationResponse reservation)
{
List <ReservationDtocs> reservationDto = _reservationApp.GetReservations();
return(reservationDto);
}
public ReservationDtocs GetReservationId(ReservationResponse reservation)
{
ReservationDtocs reservationDto = _reservationApp.GetReservationId(reservation.IdReservation);
return(reservationDto);
}
/// <summary>
/// Updates a reservation and sets the status to confirmed.
/// </summary>
/// <param name="reservationRequest">Reservation request</param>
/// <param name="profileServiceClient">Profile service client</param>
/// <returns></returns>
public ReservationResponse UpdateReservation(ReservationRequest reservationRequest, IProfileServiceClient profileServiceClient)
{
using (Profiler.Step("ReservationServiceClient.UpdateReservation"))
{
var activityId = String.Empty;
try
{
var header = ContextListBuilder.New().WithBusinessContext(ContextListAppContextSourceBusinessContext.VA)
.WithUserId(reservationRequest.UserUniqueId.ToString())
.Build();
activityId = header.DiagnosticContext.ActivityId;
var profileRequest = new ProfileRequest
{
ChainId = reservationRequest.ChainId,
HotelId = reservationRequest.HotelId,
TravelerProfileId = reservationRequest.GuestProfileId
};
var guestProfile = profileServiceClient.GetTravelerProfile(profileRequest);
using (var itineraryManagerClient = new ItineraryManagerClient(header, ServiceRegistry.AddressPool.OfType<IItineraryManager>()))
{
var updateReservationRq = new UpdateReservationRQ
{
Reservation = CreateUpdateReservationRequest(reservationRequest, guestProfile),
ReturnReservationDetails = true,
UserDetails = new UpdateReservationRQUserDetails
{
Preferences = new UpdateReservationRQUserDetailsPreferences
{
Language = new Language
{
Code = reservationRequest.Language
}
}
}
};
var updateReservationResponse = itineraryManagerClient.UpdateReservation(updateReservationRq);
var reservationResponse = new ReservationResponse
{
ApplicationResults = new ApplicationResultsModel(
updateReservationResponse.ApplicationResults.Success.IfNotNull(result => result.SystemSpecificResults.ShortText.Equals("Success"), false),
updateReservationResponse.ApplicationResults.Warning.IfNotNull(
applicationResultWarning => applicationResultWarning.Select(warning => warning.SystemSpecificResults.ShortText),
new List<String>()),
updateReservationResponse.ApplicationResults.Error.IfNotNull(applicationResultError => applicationResultError.Select(error => error.SystemSpecificResults.ShortText), new List<String>()))
};
if (reservationResponse.ApplicationResults.Success)
{
reservationResponse.Reservation = MapReservationResponse(updateReservationResponse.ReservationList.Reservation);
}
return reservationResponse;
}
}
catch (Exception exception)
{
Logger.AppLogger.Error(
"UpdateReservationUnhandledException",
exception,
"ChainId".ToKvp(reservationRequest.ChainId),
"HotelId".ToKvp(reservationRequest.HotelId),
"UserId".ToKvp(reservationRequest.UserUniqueId));
throw HttpResponseExceptionHelper.CreateHttpResponseException(activityId, exception);
}
}
}
private void TestSplitAndMerge(string reservationOrderId)
{
HttpMockServer.RecordsDirectory = GetSessionsDirectoryPath();
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var reservationsClient = ReservationsTestUtilities.GetAzureReservationAPIClient(context, new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
});
var reservations = reservationsClient.Reservation.List(reservationOrderId);
var enumerator1 = reservations.GetEnumerator();
ReservationResponse validReservation = null;
while (enumerator1.MoveNext())
{
var currentReservation = enumerator1.Current;
if (String.Equals(currentReservation.Properties.ProvisioningState, "Succeeded"))
{
validReservation = currentReservation;
break;
}
}
Assert.NotNull(validReservation);
var reservationId = validReservation.Id.Split('/')[6];
// Begin split test
SplitRequest Split = new SplitRequest(
new List <int?>()
{
1, 2
},
CreateResourceId(reservationOrderId, reservationId)
);
var splitResponse = reservationsClient.Reservation.Split(reservationOrderId, Split);
Assert.NotNull(splitResponse);
Assert.True(splitResponse.Any());
var enumerator2 = splitResponse.GetEnumerator();
ReservationResponse splitReservation1 = null;
ReservationResponse splitReservation2 = null;
while (enumerator2.MoveNext())
{
var currentReservation = enumerator2.Current;
if (String.Equals(currentReservation.Properties.ProvisioningState, "Succeeded"))
{
if (splitReservation1 == null)
{
splitReservation1 = currentReservation;
}
else
{
splitReservation2 = currentReservation;
}
}
}
var splitReservationId1 = splitReservation1.Id.Split('/')[6];
var splitReservationId2 = splitReservation2.Id.Split('/')[6];
// Begin merge test
MergeRequest Merge = new MergeRequest(
new List <string>()
{
CreateResourceId(reservationOrderId, splitReservationId1),
CreateResourceId(reservationOrderId, splitReservationId2)
}
);
var mergeResponse = reservationsClient.Reservation.Merge(reservationOrderId, Merge);
var enumerator3 = splitResponse.GetEnumerator();
ReservationResponse mergedReservation = null;
while (enumerator3.MoveNext())
{
var currentReservation = enumerator3.Current;
if (String.Equals(currentReservation.Properties.ProvisioningState, "Succeeded"))
{
mergedReservation = currentReservation;
}
}
Assert.NotNull(mergedReservation);
ValidateReservation(mergedReservation);
}
}
public ReservationDtocs GetReservationClietntId(ReservationResponse reservation)
{
ReservationDtocs reservationDto = _reservationApp.GetReservationClietntId(reservation.IdClient);
return(reservationDto);
}
