public Task <DrsOrder> GetWorkOrderDetails(string workOrderReference)
{
if (workOrderReference == "01550853")
{
throw new Exception();
}
var drsOrder = new DrsOrder
{
contract = "H01",
prop_ref = "12345",
propname = "Address name",
address1 = "Address name",
postcode = "addresspostcode",
createdDate = DateTime.Today,
dueDate = DateTime.Today.AddDays(30),
Tasks = new List <DrsTask> {
new DrsTask
{
job_code = "00210356",
comments = "Some comments",
itemValue = Decimal.MinValue,
itemqty = Decimal.MinValue,
trade = "GL",
smv = 1
}
},
wo_ref = workOrderReference
};
return(Task.Run(() => drsOrder));
}
public void build_xmb_check_availability_request_return_a_valid_request_object()
{
var mockLogger = new Mock <ILoggerAdapter <HackneyAppointmentsServiceRequestBuilder> >();
IHackneyAppointmentsServiceRequestBuilder builder =
new HackneyAppointmentsServiceRequestBuilder(new NameValueCollection(), mockLogger.Object);
var drsOrder = new DrsOrder
{
contract = "H01",
prop_ref = "12345",
propname = "The Address",
address1 = "The Address",
postcode = "addresspostcode",
createdDate = DateTime.Today,
dueDate = DateTime.Today.AddDays(30),
Tasks = new List <DrsTask> {
new DrsTask
{
job_code = "00210356",
comments = "Some comments",
itemValue = Decimal.MinValue,
itemqty = Decimal.MinValue,
trade = "GL",
smv = 1
}
}
};
var request = builder.BuildXmbCheckAvailabilityRequest("01550854", "123456", drsOrder, DateTime.Now, DateTime.Now.AddDays(7));
Assert.Equal(request.sessionId, "123456");
Assert.Equal(request.theOrder.primaryOrderNumber, "01550854");
Assert.Equal(request.theOrder.contract, "H01");
Assert.Equal(request.theOrder.locationID, "12345");
Assert.Equal(request.theOrder.theBookingCodes[0].bookingCodeSORCode, "00210356");
}
public void build_xmb_schedule_booking_request_returns_a_valid_request_object()
{
var mockLogger = new Mock <ILoggerAdapter <HackneyAppointmentsServiceRequestBuilder> >();
IHackneyAppointmentsServiceRequestBuilder builder =
new HackneyAppointmentsServiceRequestBuilder(new NameValueCollection(), mockLogger.Object);
var drsOrder = new DrsOrder
{
contract = "H01",
prop_ref = "12345",
createdDate = DateTime.Today,
dueDate = DateTime.Today.AddDays(30),
Tasks = new List <DrsTask> {
new DrsTask
{
job_code = "00210356",
comments = "Some comments",
itemValue = Decimal.MinValue,
itemqty = Decimal.MinValue,
trade = "GL",
smv = 1
}
}
};
var request = builder.BuildXmbScheduleBookingRequest("01550854", "123456", new DateTime(2017, 11, 21, 10, 00, 00), new DateTime(2017, 11, 21, 12, 00, 00), drsOrder);
Assert.Equal(request.sessionId, "123456");
Assert.Equal(request.theBooking.primaryOrderNumber, "01550854");
Assert.Equal(request.theBooking.contract, "H01");
Assert.Equal(request.theBooking.locationID, "12345");
Assert.Equal(request.theBooking.theBookingCodes[0].bookingCodeSORCode, "00210356");
Assert.Equal(request.theBooking.planningWindowStart, new DateTime(2017, 11, 21, 10, 00, 00));
Assert.Equal(request.theBooking.planningWindowEnd, new DateTime(2017, 11, 21, 12, 00, 00));
}
public async Task get_appointments_raises_an_exception_when_drs_service_responds_with_error_when_opening_session()
{
var xmbResponse = new xmbCheckAvailabilityResponse
{
status = responseStatus.success,
theSlots = new List <daySlotsInfo>().ToArray()
};
var response = new checkAvailabilityResponse(xmbResponse);
var mockLogger = new Mock <ILoggerAdapter <AppointmentActions> >();
var mockAppointmentsService = new Mock <IHackneyAppointmentsService>();
mockAppointmentsService.Setup(service => service.GetAppointmentsForWorkOrderReference(It.IsAny <xmbCheckAvailability>()))
.ReturnsAsync(response);
var sessionResponse = new openSessionResponse(
new xmbOpenSessionResponse
{
status = responseStatus.error,
sessionId = ""
}
);
var drsOrder = new DrsOrder();
mockAppointmentsService.Setup(service => service.OpenSessionAsync(It.IsAny <xmbOpenSession>()))
.ReturnsAsync(sessionResponse);
var mockRepairsService = new Mock <IHackneyRepairsService>();
mockRepairsService.Setup(service => service.GetWorkOrderDetails("0000123")).ReturnsAsync(drsOrder);
var fakeRequestBuilder = new Mock <IHackneyAppointmentsServiceRequestBuilder>();
fakeRequestBuilder.Setup(service => service.BuildXmbCheckAvailabilityRequest("0000123", "", drsOrder, DateTime.Now, DateTime.Now.AddDays(7))).Returns(new xmbCheckAvailability());
fakeRequestBuilder.Setup(service => service.BuildXmbOpenSessionRequest()).Returns(new xmbOpenSession());
var fakeRepairRequestBuilder = new Mock <IHackneyRepairsServiceRequestBuilder>();
AppointmentActions appointmentActions = new AppointmentActions(mockLogger.Object, mockAppointmentsService.Object, fakeRequestBuilder.Object, mockRepairsService.Object, fakeRepairRequestBuilder.Object);
await Assert.ThrowsAsync <AppointmentServiceException>(async() => await appointmentActions.GetAppointments("01550854"));
}
public async Task get_appointments_raises_exceptions_if_the_work_order_does_not_exists_in_UH()
{
var xmbResponse = new xmbCheckAvailabilityResponse
{
status = responseStatus.success,
theSlots = new List <daySlotsInfo>().ToArray()
};
var response = new checkAvailabilityResponse(xmbResponse);
var mockLogger = new Mock <ILoggerAdapter <AppointmentActions> >();
var mockAppointmentsService = new Mock <IHackneyAppointmentsService>();
mockAppointmentsService.Setup(service =>
service.GetAppointmentsForWorkOrderReference(It.IsAny <xmbCheckAvailability>()))
.ReturnsAsync(response);
var openSessionResponse = new openSessionResponse(
new xmbOpenSessionResponse
{
status = responseStatus.success,
sessionId = "123456"
}
);
var closeSessionResponse = new closeSessionResponse(
new xmbCloseSessionResponse
{
status = responseStatus.success
}
);
var drsOrder = new DrsOrder();
mockAppointmentsService.Setup(service => service.OpenSessionAsync(It.IsAny <xmbOpenSession>()))
.ReturnsAsync(openSessionResponse);
mockAppointmentsService.Setup(service => service.CloseSessionAsync(It.IsAny <xmbCloseSession>()))
.ReturnsAsync(closeSessionResponse);
var mockRepairsService = new Mock <IHackneyRepairsService>();
mockRepairsService.Setup(service => service.GetWorkOrderDetails("01550854")).ReturnsAsync(drsOrder);
var fakeRequestBuilder = new Mock <IHackneyAppointmentsServiceRequestBuilder>();
fakeRequestBuilder
.Setup(service => service.BuildXmbCheckAvailabilityRequest("01550854", "123456", drsOrder, DateTime.Now, DateTime.Now.AddDays(7)))
.Returns(new xmbCheckAvailability());
fakeRequestBuilder.Setup(service => service.BuildXmbOpenSessionRequest()).Returns(new xmbOpenSession());
fakeRequestBuilder.Setup(service => service.BuildXmbCreateOrderRequest("01550854", "123456", drsOrder))
.Returns(new xmbCreateOrder());
var fakeRepairRequestBuilder = new Mock <IHackneyRepairsServiceRequestBuilder>();
AppointmentActions appointmentActions = new AppointmentActions(mockLogger.Object,
mockAppointmentsService.Object, fakeRequestBuilder.Object, mockRepairsService.Object, fakeRepairRequestBuilder.Object);
await Assert.ThrowsAsync <InvalidWorkOrderInUHException>(async() =>
await appointmentActions.GetAppointments("01550854"));
}
public void build_xmb_create_order_request_return_a_valid_request_object()
{
var mockLogger = new Mock <ILoggerAdapter <HackneyAppointmentsServiceRequestBuilder> >();
IHackneyAppointmentsServiceRequestBuilder builder =
new HackneyAppointmentsServiceRequestBuilder(new NameValueCollection(), mockLogger.Object);
var bookingCodes = new List <bookingCode> {
new bookingCode
{
bookingCodeDescription = "Some comments",
bookingCodeSORCode = "00210356",
itemValue = "1.00",
primaryOrderNumber = "01550854",
trade = "GL",
standardMinuteValue = "1",
quantity = "1.00",
itemNumberWithinBooking = "1"
}
}
.ToArray();
var order = new DrsOrder
{
contract = "H01",
prop_ref = "12345",
propname = "The Address",
address1 = "The Address",
postcode = "addresspostcode",
createdDate = DateTime.Today,
dueDate = DateTime.Today.AddDays(30),
Tasks = new List <DrsTask> {
new DrsTask
{
job_code = "00210356",
comments = "Some comments",
itemValue = Decimal.MinValue,
itemqty = Decimal.MinValue,
trade = "GL",
smv = 1
}
}
};
var request = builder.BuildXmbCreateOrderRequest("01550854", "123456", order);
Assert.Equal(request.sessionId, "123456");
Assert.Equal(request.theOrder.primaryOrderNumber, "01550854");
Assert.Equal(request.theOrder.contract, "H01");
Assert.Equal(request.theOrder.locationID, "12345");
Assert.Equal(request.theOrder.theBookingCodes[0].bookingCodeSORCode, "00210356");
}
public xmbScheduleBooking BuildXmbScheduleBookingRequest(string workOrderReference, string sessionId, DateTime beginDate,
DateTime endDate, DrsOrder drsOrder)
{
var bookingCodes = drsOrder.Tasks.Select((bookingCode, i) => new bookingCode
{
bookingCodeDescription = bookingCode.comments.Trim(),
bookingCodeSORCode = bookingCode.job_code.Trim(),
itemValue = bookingCode.itemValue.ToString().Trim(),
primaryOrderNumber = workOrderReference.Trim(),
trade = bookingCode.trade.Trim(),
standardMinuteValue = bookingCode.smv.ToString().Trim(),
quantity = bookingCode.itemqty.ToString().Trim(),
itemNumberWithinBooking = i.ToString().Trim()
})
.ToArray();
var order = new order
{
primaryOrderNumber = workOrderReference.Trim(),
contract = drsOrder.contract.Trim(),
locationID = drsOrder.prop_ref.Trim(),
userId = drsOrder.userid,
theBookingCodes = bookingCodes,
priority = drsOrder.priority,
contactName = drsOrder.contactName,
orderComments = drsOrder.comments,
phone = drsOrder.phone,
message = drsOrder.txtMessage,
targetDate = drsOrder.dueDate
};
var xmbSchedulebooking = new xmbScheduleBooking
{
theBooking = new booking
{
primaryOrderNumber = workOrderReference.Trim(),
contract = drsOrder.contract.Trim(),
locationID = drsOrder.prop_ref.Trim(),
userId = drsOrder.userid,
theBookingCodes = bookingCodes,
theOrder = order,
planningWindowStart = beginDate,
planningWindowEnd = endDate,
isEmergency = false
},
sessionId = sessionId,
force = false,
userId = drsOrder.userid,
};
return(xmbSchedulebooking);
}
public async Task book_appointment_raises_an_exception_when_drs_service_responds_with_error_when_opening_session()
{
var scheduleBookingResponse = new scheduleBookingResponse(new xmbScheduleBookingResponse {
status = responseStatus.success
});
var mockLogger = new Mock <ILoggerAdapter <AppointmentActions> >();
var mockAppointmentsService = new Mock <IHackneyAppointmentsService>();
var openSessionResponse = new openSessionResponse(
new xmbOpenSessionResponse
{
status = responseStatus.error,
sessionId = ""
}
);
var closeSessionResponse = new closeSessionResponse(
new xmbCloseSessionResponse
{
status = responseStatus.success
}
);
var drsOrder = new DrsOrder {
wo_ref = "01550854"
};
mockAppointmentsService.Setup(service => service.OpenSessionAsync(It.IsAny <xmbOpenSession>()))
.ReturnsAsync(openSessionResponse);
mockAppointmentsService.Setup(service => service.CloseSessionAsync(It.IsAny <xmbCloseSession>()))
.ReturnsAsync(closeSessionResponse);
mockAppointmentsService.Setup(service => service.ScheduleBookingAsync(It.IsAny <xmbScheduleBooking>()))
.ReturnsAsync(scheduleBookingResponse);
var mockRepairsService = new Mock <IHackneyRepairsService>();
mockRepairsService.Setup(service => service.GetWorkOrderDetails("01550854")).ReturnsAsync(drsOrder);
var fakeRequestBuilder = new Mock <IHackneyAppointmentsServiceRequestBuilder>();
fakeRequestBuilder.Setup(service => service.BuildXmbOpenSessionRequest()).Returns(new xmbOpenSession());
fakeRequestBuilder.Setup(service => service.BuildXmbCloseSessionRequest("123456"))
.Returns(new xmbCloseSession());
fakeRequestBuilder.Setup(service => service.BuildXmbScheduleBookingRequest("01550854", "123456",
new DateTime(2017, 11, 21, 10, 00, 00), new DateTime(2017, 11, 21, 12, 00, 00), drsOrder))
.Returns(new xmbScheduleBooking());
var fakeRepairRequestBuilder = new Mock <IHackneyRepairsServiceRequestBuilder>();
AppointmentActions appointmentActions = new AppointmentActions(mockLogger.Object, mockAppointmentsService.Object, fakeRequestBuilder.Object, mockRepairsService.Object, fakeRepairRequestBuilder.Object);
await Assert.ThrowsAsync <AppointmentServiceException>(async() => await appointmentActions.BookAppointment("01550854", new DateTime(2017, 11, 21, 10, 00, 00), new DateTime(2017, 11, 21, 12, 00, 00)));
}
public async Task Get_workorder_details_by_reference_returns_object()
{
var mockLogger = new Mock <ILoggerAdapter <RepairsActions> >();
var drsOrder = new DrsOrder
{
postcode = "E8 2LN",
prop_ref = "12345",
priority = "N"
};
var mockRepository = new Mock <IUhtRepository>();
var mockUHWRepository = new Mock <IUhwRepository>();
mockRepository.Setup(repo => repo.GetWorkOrderDetails("123456")).ReturnsAsync(drsOrder);
var repairsService = new HackneyRepairsService(mockRepository.Object, mockUHWRepository.Object, mockLogger.Object);
var workOrder = repairsService.GetWorkOrderDetails("123456").Result;
Assert.Equal(workOrder.postcode, drsOrder.postcode);
Assert.Equal(workOrder.prop_ref, drsOrder.prop_ref);
Assert.Equal(workOrder.priority, drsOrder.priority);
}
private order buildTheOrderForRequest(string workOrderReference, DrsOrder drsOrder)
{
var bookingCodes = drsOrder.Tasks.Select((bookingCode, i) => new bookingCode
{
bookingCodeDescription = bookingCode.comments.Trim(),
bookingCodeSORCode = bookingCode.job_code.Trim(),
itemValue = bookingCode.itemValue.ToString().Trim(),
primaryOrderNumber = workOrderReference.Trim(),
trade = bookingCode.trade.Trim(),
standardMinuteValue = bookingCode.smv.ToString().Trim(),
quantity = bookingCode.itemqty.ToString().Trim(),
itemNumberWithinBooking = (i + 1).ToString().Trim()
})
.ToArray();
var repairLocation = new location
{
locationId = drsOrder.prop_ref.Trim(),
contract = drsOrder.contract.Trim(),
name = drsOrder.propname.Trim(),
address1 = drsOrder.address1.Trim(),
postCode = drsOrder.postcode.Trim()
};
return(new order
{
primaryOrderNumber = workOrderReference.Trim(),
contract = drsOrder.contract.Trim(),
locationID = drsOrder.prop_ref.Trim(),
//TODO:: need to discuss what the user id will be
userId = "createARepair",
theBookingCodes = bookingCodes,
priority = drsOrder.priority,
contactName = drsOrder.contactName,
orderComments = drsOrder.comments,
phone = drsOrder.phone,
message = drsOrder.txtMessage,
targetDate = drsOrder.dueDate,
theLocation = repairLocation
});
}
public xmbCreateOrder BuildXmbCreateOrderRequest(string workOrderReference, string sessionId, DrsOrder drsOrder)
{
var xmbCreateOrder = new xmbCreateOrder
{
sessionId = sessionId,
theOrder = buildTheOrderForRequest(workOrderReference, drsOrder)
};
return(xmbCreateOrder);
}
public async Task get_appointmets_returns_list_of_appointments_if_the_work_order_already_exists_in_DRS()
{
var xmbResponse = new xmbCheckAvailabilityResponse
{
status = responseStatus.success,
theSlots = new List <daySlotsInfo>
{
new daySlotsInfo
{
day = new DateTime(2017, 10, 18, 00, 00, 00),
nonWorkingDay = false,
daySpecified = false,
weeklyDayOff = false,
slotsForDay = new List <slotInfo>
{
new slotInfo
{
available = availableValue.YES,
beginDate = new DateTime(2017, 10, 18, 10, 00, 00),
endDate = new DateTime(2017, 10, 18, 12, 00, 00),
bestSlot = true
},
new slotInfo
{
available = availableValue.YES,
beginDate = new DateTime(2017, 10, 18, 12, 00, 00),
endDate = new DateTime(2017, 10, 18, 14, 00, 00),
bestSlot = false
},
new slotInfo
{
available = availableValue.YES,
beginDate = new DateTime(2017, 10, 18, 14, 00, 00),
endDate = new DateTime(2017, 10, 18, 16, 00, 00),
bestSlot = false
}
}.ToArray()
}
}.ToArray()
};
var response = new checkAvailabilityResponse(xmbResponse);
var mockLogger = new Mock <ILoggerAdapter <AppointmentActions> >();
var mockAppointmentsService = new Mock <IHackneyAppointmentsService>();
mockAppointmentsService.Setup(service => service.GetAppointmentsForWorkOrderReference(It.IsAny <xmbCheckAvailability>()))
.ReturnsAsync(response);
var openSessionResponse = new openSessionResponse(
new xmbOpenSessionResponse
{
status = responseStatus.success,
sessionId = "123456"
}
);
var closeSessionResponse = new closeSessionResponse(
new xmbCloseSessionResponse
{
status = responseStatus.success
}
);
var drsOrder = new DrsOrder {
wo_ref = "01550854"
};
var xmbCheckAvailabilty = new xmbCheckAvailability {
theOrder = new order {
primaryOrderNumber = "01550854"
}
};
var xmbCreateOrder =
new xmbCreateOrder {
sessionId = "123456", theOrder = new order {
primaryOrderNumber = "01550864"
}
};
var createOrderResponse = new createOrderResponse
{
@return = new xmbCreateOrderResponse
{
status = responseStatus.error,
errorMsg = "Unable to create order, an order already exists for the order number 01550854",
theOrder = new order {
orderId = 123
}
}
};
mockAppointmentsService.Setup(service => service.OpenSessionAsync(It.IsAny <xmbOpenSession>()))
.ReturnsAsync(openSessionResponse);
mockAppointmentsService.Setup(service => service.CloseSessionAsync(It.IsAny <xmbCloseSession>()))
.ReturnsAsync(closeSessionResponse);
mockAppointmentsService.Setup(service => service.CreateWorkOrderAsync(xmbCreateOrder))
.ReturnsAsync(createOrderResponse);
var mockRepairsService = new Mock <IHackneyRepairsService>();
mockRepairsService.Setup(service => service.GetWorkOrderDetails("01550854")).ReturnsAsync(drsOrder);
var fakeRequestBuilder = new Mock <IHackneyAppointmentsServiceRequestBuilder>();
fakeRequestBuilder.Setup(service => service.BuildXmbCheckAvailabilityRequest("01550854", "123456", drsOrder, DateTime.Now, DateTime.Now.AddDays(7))).Returns(xmbCheckAvailabilty);
fakeRequestBuilder.Setup(service => service.BuildXmbOpenSessionRequest()).Returns(new xmbOpenSession());
fakeRequestBuilder.Setup(service => service.BuildXmbCreateOrderRequest("01550854", "123456", drsOrder))
.Returns(xmbCreateOrder);
var fakeRepairRequestBuilder = new Mock <IHackneyRepairsServiceRequestBuilder>();
AppointmentActions appointmentActions = new AppointmentActions(mockLogger.Object, mockAppointmentsService.Object, fakeRequestBuilder.Object, mockRepairsService.Object, fakeRepairRequestBuilder.Object);
var results = await appointmentActions.GetAppointments("01550854");
Assert.Equal(results.Count, xmbResponse.theSlots[0].slotsForDay.Length);
}
public async Task <DrsOrder> GetWorkOrderDetails(string workOrderReference)
{
DrsOrder drsOrder = new DrsOrder();
_logger.LogInformation($"Getting the work order details from UHT for {workOrderReference}");
try
{
using (var command = _context.Database.GetDbConnection().CreateCommand())
{
_context.Database.OpenConnection();
command.CommandText = @"select created createdDate,
date_due dueDate,
rtrim(wo_ref) wo_ref,
rtrim(rq_name) contactName,
rtrim(sup_ref) contract,
rmworder.prop_ref,
case when (convert(varchar(50),rq_phone))>'' then convert(bit,1)
else
convert(bit,0)
end txtMessage,
rq_phone phone,
rq_priority priority,
rtrim(rmreqst.user_code) userid,
null tasks,
rtrim(short_address) propname,
short_address address1,
post_code postcode,
convert(varchar(50),rq_problem) comments
from rmworder
inner join property on rmworder.prop_ref=property.prop_ref
inner join rmreqst on rmworder.rq_ref=rmreqst.rq_ref
where wo_ref='" + workOrderReference + "'";
command.CommandType = CommandType.Text;
using (var reader = await command.ExecuteReaderAsync())
{
if (reader != null & reader.HasRows)
{
drsOrder = reader.MapToList <DrsOrder>().FirstOrDefault();
}
}
command.CommandText = @"select rmtask.job_code,
convert(varchar(50), task_text) comments,
est_cost itemValue,
est_units itemqty,
u_smv smv,
rmjob.trade
from rmtask inner join rmjob on rmtask.job_code = rmjob.job_code
where wo_ref = '" + workOrderReference + "'";
command.CommandType = CommandType.Text;
using (var reader = await command.ExecuteReaderAsync())
{
drsOrder.Tasks = reader.MapToList <DrsTask>();
}
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
}
return(drsOrder);
}
public xmbCheckAvailability BuildXmbCheckAvailabilityRequest(string workOrderReference, string sessionId, DrsOrder drsOrder, DateTime startPeriod, DateTime endPeriod)
{
_logger.LogInformation($"Building the xmbCheckAvailability request for {workOrderReference}");
try
{
var xmbCheckAvailability = new xmbCheckAvailability
{
theOrder = buildTheOrderForRequest(workOrderReference, drsOrder),
sessionId = sessionId,
periodBegin = startPeriod,
periodEnd = endPeriod,
periodBeginSpecified = true,
periodEndSpecified = true,
canSelectOtherOrders = false,
checkAvailType = checkAvailTypeType.standard,
onlyBestSlots = onlyBestSlotsValue.fullPeriod
};
return(xmbCheckAvailability);
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
}
return(null);
}
public async Task get_appointments_raises_exceptions_if_service_fails_to_create_order_in_DRS()
{
var xmbResponse = new xmbCheckAvailabilityResponse
{
status = responseStatus.success,
theSlots = new List <daySlotsInfo>().ToArray()
};
var response = new checkAvailabilityResponse(xmbResponse);
var mockLogger = new Mock <ILoggerAdapter <AppointmentActions> >();
var mockAppointmentsService = new Mock <IHackneyAppointmentsService>();
mockAppointmentsService.Setup(service =>
service.GetAppointmentsForWorkOrderReference(It.IsAny <xmbCheckAvailability>()))
.ReturnsAsync(response);
var openSessionResponse = new openSessionResponse(
new xmbOpenSessionResponse
{
status = responseStatus.success,
sessionId = "123456"
}
);
var closeSessionResponse = new closeSessionResponse(
new xmbCloseSessionResponse
{
status = responseStatus.success
}
);
var createOrderResponse = new createOrderResponse
{
@return = new xmbCreateOrderResponse
{
status = responseStatus.error,
errorMsg = "error creating the order"
}
};
var drsOrder = new DrsOrder {
wo_ref = "01550854"
};
var xmbCheckAvailabilty = new xmbCheckAvailability {
theOrder = new order {
primaryOrderNumber = "01550854"
}
};
var xmbCreateOrder =
new xmbCreateOrder {
sessionId = "123456", theOrder = new order {
primaryOrderNumber = "01550864"
}
};
mockAppointmentsService.Setup(service => service.OpenSessionAsync(It.IsAny <xmbOpenSession>()))
.ReturnsAsync(openSessionResponse);
mockAppointmentsService.Setup(service => service.CloseSessionAsync(It.IsAny <xmbCloseSession>()))
.ReturnsAsync(closeSessionResponse);
mockAppointmentsService.Setup(service => service.CreateWorkOrderAsync(xmbCreateOrder))
.ReturnsAsync(createOrderResponse);
var mockRepairsService = new Mock <IHackneyRepairsService>();
mockRepairsService.Setup(service => service.GetWorkOrderDetails("01550854")).ReturnsAsync(drsOrder);
var fakeRequestBuilder = new Mock <IHackneyAppointmentsServiceRequestBuilder>();
fakeRequestBuilder
.Setup(service => service.BuildXmbCheckAvailabilityRequest("01550854", "123456", drsOrder, DateTime.Now, DateTime.Now.AddDays(7)))
.Returns(xmbCheckAvailabilty);
fakeRequestBuilder.Setup(service => service.BuildXmbOpenSessionRequest()).Returns(new xmbOpenSession());
fakeRequestBuilder.Setup(service => service.BuildXmbCreateOrderRequest("01550854", "123456", drsOrder))
.Returns(xmbCreateOrder);
var fakeRepairRequestBuilder = new Mock <IHackneyRepairsServiceRequestBuilder>();
AppointmentActions appointmentActions = new AppointmentActions(mockLogger.Object,
mockAppointmentsService.Object, fakeRequestBuilder.Object, mockRepairsService.Object, fakeRepairRequestBuilder.Object);
await Assert.ThrowsAsync <AppointmentServiceException>(async() =>
await appointmentActions.GetAppointments("01550854"));
}
public async Task get_appointments_raises_an_exception_if_the_slots_list_is_missing()
{
var xmbResponse = new xmbCheckAvailabilityResponse
{
status = responseStatus.success,
theSlots = null
};
var response = new checkAvailabilityResponse(xmbResponse);
var mockLogger = new Mock <ILoggerAdapter <AppointmentActions> >();
var mockAppointmentsService = new Mock <IHackneyAppointmentsService>();
mockAppointmentsService.Setup(service => service.GetAppointmentsForWorkOrderReference(It.IsAny <xmbCheckAvailability>()))
.ReturnsAsync(response);
var sessionResponse = new openSessionResponse(
new xmbOpenSessionResponse
{
status = responseStatus.success,
sessionId = "123456"
}
);
var closeSessionResponse = new closeSessionResponse(
new xmbCloseSessionResponse
{
status = responseStatus.success
}
);
var drsOrder = new DrsOrder {
wo_ref = "01550854"
};
var xmbCheckAvailabilty = new xmbCheckAvailability {
theOrder = new order {
primaryOrderNumber = "01550854"
}
};
var xmbCreateOrder =
new xmbCreateOrder {
sessionId = "123456", theOrder = new order {
primaryOrderNumber = "01550864"
}
};
var createOrderResponse = new createOrderResponse
{
@return = new xmbCreateOrderResponse
{
status = responseStatus.success,
theOrder = new order {
orderId = 123
}
}
};
mockAppointmentsService.Setup(service => service.OpenSessionAsync(It.IsAny <xmbOpenSession>()))
.ReturnsAsync(sessionResponse);
mockAppointmentsService.Setup(service => service.CloseSessionAsync(It.IsAny <xmbCloseSession>()))
.ReturnsAsync(closeSessionResponse);
mockAppointmentsService.Setup(service => service.CreateWorkOrderAsync(xmbCreateOrder))
.ReturnsAsync(createOrderResponse);
var mockRepairsService = new Mock <IHackneyRepairsService>();
mockRepairsService.Setup(service => service.GetWorkOrderDetails("01550854")).ReturnsAsync(drsOrder);
var fakeRequestBuilder = new Mock <IHackneyAppointmentsServiceRequestBuilder>();
fakeRequestBuilder.Setup(service => service.BuildXmbCheckAvailabilityRequest("01550854", "123456", drsOrder, DateTime.Now, DateTime.Now.AddDays(7))).Returns(xmbCheckAvailabilty);
fakeRequestBuilder.Setup(service => service.BuildXmbCreateOrderRequest("01550854", "123456", drsOrder))
.Returns(xmbCreateOrder);
var fakeRepairRequestBuilder = new Mock <IHackneyRepairsServiceRequestBuilder>();
AppointmentActions appointmentActions = new AppointmentActions(mockLogger.Object, mockAppointmentsService.Object, fakeRequestBuilder.Object, mockRepairsService.Object, fakeRepairRequestBuilder.Object);
await Assert.ThrowsAsync <MissingSlotsException>(async() => await appointmentActions.GetAppointments("01550854"));
}
private async Task <List <Slot> > getAppointmentSlots(string workOrderReference, string sessionId, DrsOrder drsOrder, DateTime startPeriod, DateTime endPeriod)
{
var request =
_appointmentsServiceRequestBuilder.BuildXmbCheckAvailabilityRequest(workOrderReference, sessionId, drsOrder, startPeriod, endPeriod);
// get the appointments
var response = await _appointmentsService.GetAppointmentsForWorkOrderReference(request);
var responseString = response.@return;
if (responseString.status != responseStatus.success)
{
_logger.LogError(responseString.errorMsg);
throw new AppointmentServiceException();
}
var slots = responseString.theSlots;
if (slots == null)
{
_logger.LogError($"Missing the slots from the response string {responseString}");
throw new MissingSlotsException();
}
var slotList = new List <Slot>();
foreach (var slot in slots)
{
slotList.AddRange(buildSlot(slot));
}
return(slotList.Where(slot => slot.Available).ToList());
}
private async Task <createOrderResponse> CreateWorkOrderInDrs(string workOrderReference, string sessionId, DrsOrder drsOrder)
{
// build the request
var request = _appointmentsServiceRequestBuilder.BuildXmbCreateOrderRequest(workOrderReference, sessionId, drsOrder);
//create the work order
var response = await _appointmentsService.CreateWorkOrderAsync(request);
var returnResponse = response.@return;
if (returnResponse.status == responseStatus.error && returnResponse.errorMsg.Contains("order already exists"))
{
_logger.LogInformation($"Unable to create order in DRS, an order already exists with order reference {workOrderReference}");
[email protected] = responseStatus.success;
}
return(response);
}
public async Task book_appointment_returns_success_result()
{
var scheduleBookingResponse = new scheduleBookingResponse(new xmbScheduleBookingResponse {
status = responseStatus.success
});
var mockLogger = new Mock <ILoggerAdapter <AppointmentActions> >();
var mockAppointmentsService = new Mock <IHackneyAppointmentsService>();
var openSessionResponse = new openSessionResponse(
new xmbOpenSessionResponse
{
status = responseStatus.success,
sessionId = "123456"
}
);
var closeSessionResponse = new closeSessionResponse(
new xmbCloseSessionResponse
{
status = responseStatus.success
}
);
var drsOrder = new DrsOrder {
wo_ref = "01550854"
};
var xmbScheduleBooking = new xmbScheduleBooking
{
theBooking = new booking()
};
mockAppointmentsService.Setup(service => service.OpenSessionAsync(It.IsAny <xmbOpenSession>()))
.ReturnsAsync(openSessionResponse);
mockAppointmentsService.Setup(service => service.CloseSessionAsync(It.IsAny <xmbCloseSession>()))
.ReturnsAsync(closeSessionResponse);
mockAppointmentsService.Setup(service => service.ScheduleBookingAsync(xmbScheduleBooking))
.ReturnsAsync(scheduleBookingResponse);
mockAppointmentsService.Setup(service => service.SelectOrderAsync(It.IsAny <xmbSelectOrder>()))
.ReturnsAsync(new selectOrderResponse(new xmbSelectOrderResponse
{
status = responseStatus.success,
theOrders = new List <order>
{
new order
{
contract = "H01",
theBookings = new List <booking>
{
new booking
{
bookingId = 123456
}
}.ToArray(),
theLocation = new location
{
locationId = "012345",
contract = "H01",
name = "An address",
address1 = "An address",
postCode = "Apostcode"
}
}
}.ToArray()
}));
var mockWorksOrderResponse = new RepairsService.WebResponse
{
Success = true
};
var mockRepairsService = new Mock <IHackneyRepairsService>();
mockRepairsService.Setup(service => service.GetWorkOrderDetails("01550854")).ReturnsAsync(drsOrder);
mockRepairsService.Setup(service => service.IssueOrderAsync(It.IsAny <RepairsService.WorksOrderRequest>()))
.ReturnsAsync(mockWorksOrderResponse);
var fakeRequestBuilder = new Mock <IHackneyAppointmentsServiceRequestBuilder>();
fakeRequestBuilder.Setup(service => service.BuildXmbOpenSessionRequest()).Returns(new xmbOpenSession());
fakeRequestBuilder.Setup(service => service.BuildXmbCloseSessionRequest("123456"))
.Returns(new xmbCloseSession());
fakeRequestBuilder.Setup(service => service.BuildXmbScheduleBookingRequest("01550854", "123456",
new DateTime(2017, 11, 21, 10, 00, 00), new DateTime(2017, 11, 21, 12, 00, 00), drsOrder))
.Returns(xmbScheduleBooking);
var fakeRepairRequestBuilder = new Mock <IHackneyRepairsServiceRequestBuilder>();
AppointmentActions appointmentActions = new AppointmentActions(mockLogger.Object, mockAppointmentsService.Object, fakeRequestBuilder.Object, mockRepairsService.Object, fakeRepairRequestBuilder.Object);
var result = await appointmentActions.BookAppointment("01550854", new DateTime(2017, 11, 21, 10, 00, 00), new DateTime(2017, 11, 21, 12, 00, 00));
Assert.Contains("{ beginDate = 2017-11-21T10:00:00Z, endDate = 2017-11-21T12:00:00Z }", result.ToString());
}
