public ActionResult <BookingAdapterOut> Post([FromBody] BookingAdapterIn value)
{
try
{
BookingOrder booking = _bookingService.Create(new BookingOrder
{
Id = value.Id,
Product = _productService.Read(value.Product.Id),
User = _UserInfoservice.Read(value.User.Id),
StartTimeOfBooking = DateConverter.FromUTCEpochToDatetime(value.StartTimeOfBooking),
EndTimeOfBooking = DateConverter.FromUTCEpochToDatetime(value.EndTimeOfBooking)
});
return(Created("" + booking.Id, new BookingAdapterOut
{
Id = booking.Id,
Product = booking.Product,
User = booking.User,
StartTimeOfBooking = DateConverter.FromDatetimeToUTCEpoch(booking.StartTimeOfBooking),
EndTimeOfBooking = DateConverter.FromDatetimeToUTCEpoch(booking.EndTimeOfBooking)
}));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <string> Handle(CreateBookingCommand request, CancellationToken cancellationToken)
{
//Create Agreegate Root
var bookingOrder = new BookingOrder(request.CustomerId, request.Origin, request.Destination
, bookingStateEnum.Pending);
//Add Order Details
foreach (BookingOrderDetails bookdetails in request.BookingDetails)
{
bookingOrder.AddBookingDetails(bookingOrder.BookingOrderId,
bookdetails.PackageType, bookdetails.PackageDescription, bookdetails.Price);
}
//Create Integration Event
var bookingAddIntegrationEvent = new BookingAddIntegrationEvent(bookingOrder.BookingOrderId,
bookingOrder.Origin,
bookingOrder.Destination);
//Save the Data in local DB
var booking = await _bookingContext.AddAsync(bookingOrder);
//Publish Event to Service Bus Topic
_eventBus.Publish(bookingAddIntegrationEvent);
//Return Booking Ref
return(booking);
}
public override async Task DeleteModel(int id)
{
BlockingPlan model = await ReadModelById(id);
var workschedules = model.WorkSchedules;
foreach (var workschedule in workschedules)
{
await WeeklyPlanLogic.DeleteByWeeklyplanItemByIdAndWeekId(workschedule);
}
foreach (var item in model.WorkSchedules)
{
//EntityExtension.FlagForDelete(item, IdentityService.Username, "masterplan-service");
await BlockingPlanWorkScheduleLogic.DeleteModel(item.Id);
}
BookingOrder bookingOrder = await BookingOrderLogic.ReadModelById(model.BookingOrderId);
BookingOrderLogic.UpdateModelBlockingPlanId(bookingOrder.Id, bookingOrder, null);
EntityExtension.FlagForDelete(model, IdentityService.Username, "masterplan-service", true);
DbSet.Update(model);
await DbContext.SaveChangesAsync();
}
public static void Insert(BookingOrder order)
{
var list = new List <Notification>();
var curDate = order.CheckinDate;
while (true)
{
var date = curDate.AddMonths(order.PaymentCycle.Value);
if (DateTime.Compare(date, order.CheckOutDate) > 0)
{
break;
}
for (int i = 5; i > 0; i--)
{
var notification = new Notification
{
Id = "n-" + IdHelper.Generate(),
OrderId = order.Id,
Customers = order.Customers,
Rooms = order.Rooms,
Date = date.Subtract(TimeSpan.FromDays(i)),
DaysToPaymentDate = i
};
list.Add(notification);
}
curDate = date;
}
foreach (var notification in list)
{
Insert(notification);
}
}
public async Task <int> SetRemainingOrderQuantity(BookStatusViewModel bookStatus)
{
BookingOrder model = await BookingOrderLogic.ReadModelById(bookStatus.BookingOrderId);
int total = 0;
foreach (BookingOrderDetail item in model.DetailConfirms)
{
total += item.Total;
}
if (model.InitialOrderQuantity == null)
{
model.InitialOrderQuantity = model.OrderQuantity;
}
var orderQuantity = model.OrderQuantity;
var orderCanceledOrDeleted = Math.Abs(total - orderQuantity);
var nowDateAndTime = DateTimeOffset.Now;
model.OrderQuantity = total;
var blockingPlan = await BlockingPlanLogic.searchByBookingOrderId(bookStatus.BookingOrderId);
if (bookStatus.StatusBooking == StatusConst.CANCEL_REMAINING)
{
if (blockingPlan != null)
{
if (total == 0)
{
BlockingPlanLogic.UpdateModelStatus(blockingPlan.Id, blockingPlan, BlockingPlanStatus.CANCELLED);
}
else
{
BlockingPlanLogic.UpdateModelStatus(blockingPlan.Id, blockingPlan, BlockingPlanStatus.CHANGED);
}
}
model.CanceledBookingOrder = orderCanceledOrDeleted;
model.CanceledDate = nowDateAndTime;
}
else if (bookStatus.StatusBooking == StatusConst.DELETE_REMAINING)
{
if (blockingPlan != null)
{
if (total == 0)
{
BlockingPlanLogic.UpdateModelStatus(blockingPlan.Id, blockingPlan, BlockingPlanStatus.EXPIRED);
}
else
{
BlockingPlanLogic.UpdateModelStatus(blockingPlan.Id, blockingPlan, BlockingPlanStatus.CHANGED);
}
}
model.ExpiredBookingOrder = orderCanceledOrDeleted;
model.ExpiredDeletedDate = nowDateAndTime;
}
return(await Update(bookStatus.BookingOrderId, model));
}
public async Task <int> Update(int id, BookingOrder model)
{
Boolean hasBlockingPlan = false;
try
{
if (model.DetailConfirms.Count != 0)
{
// Before Update Check if Booking Order Have Blocking Plan ?
hasBlockingPlan = await BlockingPlanLogic.UpdateModelStatus(id, BlockingPlanStatus.CHANGED);
// IF hasBlockingPlan = True
if (hasBlockingPlan)
{
model.IsModified = true;
}
}
BookingOrderLogic.UpdateModel(id, model);
return(await DbContext.SaveChangesAsync());
}
catch (Exception Ex)
{
throw new Exception($"Terjadi Kesalahan Update Booking Order, dengan Kesalahan Sebagai Berikut: {Ex.ToString()}");
}
}
public void TestBookingOrderServiceUpdateInvalidOperationExceptionContainsNullUser(long id, bool isUserNull, bool isProductNull, bool isBookingNull)
{
DateTime start = DateTime.Now.AddHours(1);
DateTime end = DateTime.Now.AddHours(3);
UserInfo user = isUserNull ? null : new UserInfo();
Product product = isProductNull ? null : new Product();
BookingOrder boBeforeCreated = isBookingNull ? null : new BookingOrder()
{
User = user,
Product = product,
StartTimeOfBooking = start,
EndTimeOfBooking = end
};
BookingOrder boAfterCreated = isBookingNull ? null : new BookingOrder()
{
Id = id,
User = user,
Product = product,
StartTimeOfBooking = start,
EndTimeOfBooking = end
};
_mockRepo.Setup(x => x.Update(boBeforeCreated)).Returns(boAfterCreated);
Assert.ThrowsException <InvalidDataException>(() => _service.Create(boBeforeCreated));
_mockRepo.Verify(x => x.Update(It.IsAny <BookingOrder>()), Times.Never);
}
public async Task <IActionResult> Get(string Id)
{
try
{
_logger.LogInformation("Log message in the Booking.API.Get() method");
BookingOrder resultSet = await Mediator.Send(new GetBookingQuery()
{
BookingId = Id
});
if (resultSet == null)
{
return(NotFound());
}
var bookingDTO = Mapper.Map <BookingOrderDTO>(resultSet);
return(Ok(bookingDTO));
}
catch (Exception ex)
{
_logger.LogInformation("Exception in Booking.API-> Get: " + ex);
telemetry.TrackException(ex);
return(StatusCode(StatusCodes.Status500InternalServerError, "Sorry Some problem Occured"));
}
}
public void TestBookingOrderServiceUpdateInvalidDataExceptionDate(long id, int addStart, int addEnd)
{
DateTime start = DateTime.Now.AddHours(addStart);
DateTime end = DateTime.Now.AddHours(addEnd);
UserInfo user = new UserInfo();
Product product = new Product();
BookingOrder boBeforeCreated = new BookingOrder()
{
User = user,
Product = product,
StartTimeOfBooking = start,
EndTimeOfBooking = end
};
BookingOrder boAfterCreated = new BookingOrder()
{
Id = id,
User = user,
Product = product,
StartTimeOfBooking = start,
EndTimeOfBooking = end
};
_mockRepo.Setup(x => x.Update(boBeforeCreated)).Returns(boAfterCreated);
Assert.ThrowsException <InvalidDataException>(() => _service.Update(boBeforeCreated));
_mockRepo.Verify(x => x.Update(It.IsAny <BookingOrder>()), Times.Never);
}
public HttpResponseMessage Update(BookingOrder order)
{
return(Execute(session =>
{
OrderService.Update(order);
return Request.CreateResponse(HttpStatusCode.OK);
}));
}
public HttpResponseMessage Checkout(BookingOrder order)
{
return(Execute(session =>
{
OrderService.Checkout(order);
return Request.CreateResponse(HttpStatusCode.NoContent);
}));
}
//Add the book
public async Task <string> AddAsync(BookingOrder bookingOrder)
{
bookingOrder.CreatedDate = DateTime.Now;
_context.Set <BookingOrder>().Add(bookingOrder);
await _context.SaveChangesAsync();
return(bookingOrder.BookingOrderId);
}
//Update The Booking
public async Task <BookingOrder> UpdateAsync(BookingOrder bookingOrder)
{
bookingOrder.UpdatedDate = DateTime.Now;
//_context.Bookings.Update(bookingOrder);
await _context.SaveChangesAsync();
return(bookingOrder);
}
public ActionResult <BookingOrder> PostBookingOrder(string traderName, string productCode, int amount, decimal threshold)
{
var Trader = pandaRepo.GetTraderByName(traderName);
var MarketProduct = pandaRepo.GetMarketProduct(productCode);
var bookingOrder = new BookingOrder(Trader, MarketProduct, amount, threshold);
pandaRepo.PlaceBookingOrder(bookingOrder);
return(CreatedAtAction("GetBookingOrder", new { id = bookingOrder.Id }, bookingOrder));
}
private bool IsBookingTimeColiding(BookingOrder booking)
{
IEnumerable <BookingOrder> bookings = _repo.ReadAll();
return(bookings.Where(bo => bo.Id != booking.Id).Where(bo => bo.Product.Id == booking.Product.Id)
.Where(bo =>
(bo.StartTimeOfBooking.Ticks + 1 <= booking.StartTimeOfBooking.Ticks + 1 && bo.EndTimeOfBooking.Ticks - 1 >= booking.StartTimeOfBooking.Ticks + 1) ||
(bo.StartTimeOfBooking.Ticks + 1 <= booking.EndTimeOfBooking.Ticks - 1 && bo.EndTimeOfBooking.Ticks - 1 >= booking.EndTimeOfBooking.Ticks - 1) ||
(booking.StartTimeOfBooking.Ticks + 1 <= bo.StartTimeOfBooking.Ticks + 1 && booking.EndTimeOfBooking.Ticks - 1 >= bo.EndTimeOfBooking.Ticks - 1))
.FirstOrDefault() != null);
}
public void TestBookingOrderServiceUpdate(long id, int oldStart, int oldEnd, int newStart, int newEnd, int prod1Id, int prod2Id)
{
UserInfo user = new UserInfo();
Product product = new Product()
{
Id = prod1Id
};
Product product2 = new Product()
{
Id = prod2Id
};
DateTime cal = DateTime.Now;
DateTime start = new DateTime(cal.Year + 1, cal.Month, cal.Day, 10 + oldStart, 0, 0);
DateTime end = new DateTime(cal.Year + 1, cal.Month, cal.Day, 10 + oldEnd, 0, 0);
DateTime start2 = new DateTime(cal.Year + 1, cal.Month, cal.Day, 10 + newStart, 0, 0);
DateTime end2 = new DateTime(cal.Year + 1, cal.Month, cal.Day, 10 + newEnd, 0, 0);
BookingOrder oldBooking = new BookingOrder()
{
Id = id,
User = user,
Product = product,
StartTimeOfBooking = start,
EndTimeOfBooking = end
};
BookingOrder updatedBooking = new BookingOrder()
{
Id = id,
User = user,
Product = product,
StartTimeOfBooking = start2,
EndTimeOfBooking = end2
};
IEnumerable <BookingOrder> bookingOrders = new List <BookingOrder>()
{
new BookingOrder()
{
Id = id + 1,
User = user,
Product = product2,
StartTimeOfBooking = start,
EndTimeOfBooking = end
},
oldBooking
};
_mockRepo.Setup(repo => repo.ReadAll()).Returns(bookingOrders);
_mockRepo.Setup(x => x.Read(id)).Returns(updatedBooking);
_mockRepo.Setup(x => x.Update(updatedBooking)).Returns(updatedBooking);
Assert.IsTrue(_service.Update(updatedBooking) != null);
_mockRepo.Verify(x => x.Update(It.IsAny <BookingOrder>()), Times.Once);
}
public void TestBookingOrderServiceUpdateInvalidDataExceptionTimeCollision(long id, int oldStart, int oldEnd, int newStart, int newEnd, int bStart3, int bEnd3, int prod1Id)
{
UserInfo user = new UserInfo();
Product product = new Product()
{
Id = prod1Id
};
DateTime cal = DateTime.Now;
DateTime start = new DateTime(cal.Year + 1, cal.Month, cal.Day, 10 + oldStart, 0, 0);
DateTime end = new DateTime(cal.Year + 1, cal.Month, cal.Day, 10 + oldEnd, 0, 0);
DateTime start2 = new DateTime(cal.Year + 1, cal.Month, cal.Day, 10 + newStart, 0, 0);
DateTime end2 = new DateTime(cal.Year + 1, cal.Month, cal.Day, 10 + newEnd, 0, 0);
DateTime start3 = new DateTime(cal.Year + 1, cal.Month, cal.Day, 10 + bStart3, 0, 0);
DateTime end3 = new DateTime(cal.Year + 1, cal.Month, cal.Day, 10 + bEnd3, 0, 0);
BookingOrder oldBooking = new BookingOrder()
{
Id = id,
User = user,
Product = product,
StartTimeOfBooking = start,
EndTimeOfBooking = end
};
BookingOrder updatedBooking = new BookingOrder()
{
Id = id,
User = user,
Product = product,
StartTimeOfBooking = start2,
EndTimeOfBooking = end2
};
IEnumerable <BookingOrder> bookingOrders = new List <BookingOrder>()
{
new BookingOrder()
{
Id = id + 1,
User = user,
Product = product,
StartTimeOfBooking = start3,
EndTimeOfBooking = end3
},
oldBooking
};
_mockRepo.Setup(repo => repo.ReadAll()).Returns(bookingOrders);
_mockRepo.Setup(x => x.Read(id)).Returns(updatedBooking);
_mockRepo.Setup(x => x.Update(updatedBooking)).Returns(updatedBooking);
Assert.ThrowsException <InvalidDataException>(() => _service.Update(updatedBooking));
_mockRepo.Verify(x => x.Update(It.IsAny <BookingOrder>()), Times.Never);
}
public async Task DeleteBookingOrderAsync(BookingOrder bookingOrder, string accessToken)
{
var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
var json = JsonConvert.SerializeObject(bookingOrder);
HttpContent content = new StringContent(json);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
await client.PostAsync(Constants.BaseApiAddress + "api/CustomerMobile/DeleteBookingOrder/", content);
}
public async Task <int> Create(BookingOrder model)
{
int latestSN = this.DbSet
.Where(d => d.SectionId.Equals(model.SectionId) && d.BuyerId.Equals(model.BuyerId) && d.BookingDate.Year.Equals(model.BookingDate.Year))
.DefaultIfEmpty()
.Max(d => d.SerialNumber);
model.SerialNumber = latestSN != 0 ? latestSN + 1 : 1;
model.Code = String.Format("{0}-{1}-{2:D2}{3}", model.SectionCode, model.BuyerCode, model.BookingDate.Year, model.SerialNumber);
BookingOrderLogic.CreateModel(model);
return(await DbContext.SaveChangesAsync());
}
public JsonResult AddCart(ExcursionAddWebParam param)
{
if (param == null)
{
throw new ArgumentNullException("param");
}
List <string> list = new List <string>();
if (param.excursion != null)
{
if ((param.excursion.pax != null) && ((param.excursion.pax.adult + param.excursion.pax.child) > 0))
{
if (param.cid == null)
{
int?nullable = null;
using (ShoppingCart cart = ShoppingCart.CreateFromSession(base.Session))
{
cart.PartnerAlias = param.PartnerAlias;
cart.PartnerSessionID = param.psid;
BookingOrder item = new BookingOrder {
orderid = Guid.NewGuid().ToString(),
excursion = param.excursion
};
cart.Orders.Add(item);
nullable = new int?(cart.Orders.Count);
}
return(base.Json(new { ok = true, ordercount = nullable }));
}
WebPartner partner = UserToolsProvider.GetPartner(param);
BookingOrder order2 = new BookingOrder {
orderid = Guid.NewGuid().ToString(),
excursion = param.excursion
};
ExternalCartAddOrderResult result = BookingProvider.ExternalCart_AddOrder(UrlLanguage.CurrentLanguage, partner, param.cid, order2);
if (result.errorcode == 0)
{
return(base.Json(new { ok = true, ordercount = result.ordercount }));
}
list.Add(result.errormessage);
}
else
{
list.Add(ExcursionStrings.ResourceManager.Get("ErrorGuestCount"));
}
}
else
{
list.Add(ExcursionStrings.ResourceManager.Get("ErrorInvalidParams"));
}
return(base.Json(new { errormessages = list.ToArray() }));
}
public static void Update(BookingOrder order)
{
order.TotalGuest = order.Customers.Count;
var originalOrder = GetById(order.Id);
SqlHelper.StartTransaction(ConfigManager.ConnectionString, (connection, transaction) =>
{
// update order
SqlHelper.ExecuteCommand(connection, transaction, CommandType.StoredProcedure, SP_ORDER_UPDATE, CreateParams(order));
// update customer
foreach (var customer in order.Customers)
{
string spName;
if (customer.Id.StartsWith("customer-"))
{
customer.Id = "c-" + IdHelper.Generate();
spName = SP_CUSTOMER_INSERT;
SqlHelper.ExecuteCommand(connection, transaction, CommandType.StoredProcedure, SP_ORDER_CUSTOMER_INSERT,
new[]
{
new SqlParameter("@orderId", order.Id),
new SqlParameter("@customerId", customer.Id),
});
}
else
{
spName = SP_CUSTOMER_UPDATE;
}
SqlHelper.ExecuteCommand(connection, transaction, CommandType.StoredProcedure, spName, CreateParams(customer));
}
// update deposit
SqlHelper.ExecuteCommand(connection, transaction, CommandType.StoredProcedure, SP_DEPOSIT_UPDATE,
new[]
{
new SqlParameter("@id", order.Deposit.Id),
new SqlParameter("@date", order.Deposit.Date),
new SqlParameter("@amount", order.Deposit.Amount),
new SqlParameter("@unit", order.Deposit.Unit),
});
UpdatePaymentForOrder(order, originalOrder, connection, transaction);
});
NotificationService.DeleteByOrderId(order.Id);
NotificationService.Insert(order);
}
public JsonResult AddCart(ExcursionAddWebParam param)
{
if (param == null)
{
throw new ArgumentNullException("param");
}
List<string> list = new List<string>();
if (param.excursion != null)
{
if ((param.excursion.pax != null) && ((param.excursion.pax.adult + param.excursion.pax.child) > 0))
{
if (param.cid == null)
{
int? nullable = null;
using (ShoppingCart cart = ShoppingCart.CreateFromSession(base.Session))
{
cart.PartnerAlias = param.PartnerAlias;
cart.PartnerSessionID = param.psid;
BookingOrder item = new BookingOrder {
orderid = Guid.NewGuid().ToString(),
excursion = param.excursion
};
cart.Orders.Add(item);
nullable = new int?(cart.Orders.Count);
}
return base.Json(new { ok = true, ordercount = nullable });
}
WebPartner partner = UserToolsProvider.GetPartner(param);
BookingOrder order2 = new BookingOrder {
orderid = Guid.NewGuid().ToString(),
excursion = param.excursion
};
ExternalCartAddOrderResult result = BookingProvider.ExternalCart_AddOrder(UrlLanguage.CurrentLanguage, partner, param.cid, order2);
if (result.errorcode == 0)
{
return base.Json(new { ok = true, ordercount = result.ordercount });
}
list.Add(result.errormessage);
}
else
{
list.Add(ExcursionStrings.ResourceManager.Get("ErrorGuestCount"));
}
}
else
{
list.Add(ExcursionStrings.ResourceManager.Get("ErrorInvalidParams"));
}
return base.Json(new { errormessages = list.ToArray() });
}
private static SqlParameter[] CreateParams(BookingOrder order)
{
return(new[]
{
new SqlParameter("@id", order.Id),
new SqlParameter("@note", order.Note),
new SqlParameter("@checkinDate", order.CheckinDate),
new SqlParameter("@checkoutDate", order.CheckOutDate),
new SqlParameter("@totalGuest", order.TotalGuest),
new SqlParameter("@stayLength", order.StayLength),
new SqlParameter("@status", order.Status),
new SqlParameter("@houseId", order.HouseId),
new SqlParameter("@paymentCycle", order.PaymentCycle.ToString()),
});
}
public static void Checkout(BookingOrder order)
{
order.Status = "Completed";
var originalOrder = GetById(order.Id);
SqlHelper.StartTransaction(ConfigManager.ConnectionString, (connection, transaction) =>
{
// update order
SqlHelper.ExecuteCommand(connection, transaction, CommandType.StoredProcedure, SP_ORDER_UPDATE, CreateParams(order));
UpdatePaymentForOrder(order, originalOrder, connection, transaction);
});
NotificationService.DeleteByOrderId(order.Id);
}
private static BookingOrder Parse(IDataReader reader)
{
var ps = new PaymentRecordService();
reader.Read();
var order = new BookingOrder
{
Id = reader["Id"].ToString(),
CheckinDate = DateTime.Parse(reader["CheckinDate"].ToString()),
CheckOutDate = DateTime.Parse(reader["CheckoutDate"].ToString()),
Note = reader["Note"]?.ToString() ?? string.Empty,
Status = reader["Status"].ToString(),
TotalGuest = int.Parse(reader["TotalGuest"].ToString()),
StayLength = reader["StayLength"].ToString(),
HouseId = reader["HouseId"].ToString(),
PaymentCycle = new PaymentCycle(reader["PaymentCycle"].ToString())
};
order.Deposit = new Deposit
{
OrderId = order.Id,
Id = reader["DepositId"].ToString(),
Amount = reader["DepositAmount"].ToString(),
Unit = reader["DepositUnit"].ToString(),
Date = DateTime.Parse(reader["DepositDate"].ToString())
};
reader.NextResult();
order.Customers = new List <Customer>();
while (reader.Read())
{
var customer = CustomerService.GetById(reader["CustomerId"].ToString());
order.Customers.Add(customer);
}
reader.NextResult();
order.Rooms = new List <Room>();
while (reader.Read())
{
var room = RoomService.GetById(reader["RoomId"].ToString());
order.Rooms.Add(room);
}
order.Discounts = ps.GetByOrderId(order.Id, "Order-Discount");
order.Payments = ps.GetByOrderId(order.Id, "Order-Payment");
return(order);
}
public void TestBookingOrderServiceCreate(long id, int addStart, int addEnd, int oldStart, int oldEnd, int prodid, int prod2id)
{
DateTime start = DateTime.Now.AddHours(addStart);
DateTime end = DateTime.Now.AddHours(addEnd);
UserInfo user = new UserInfo();
Product product = new Product()
{
Id = prodid
};
Product product2 = new Product()
{
Id = prod2id
};
IEnumerable <BookingOrder> bookingOrders = new List <BookingOrder>()
{
new BookingOrder()
{
Id = id + 1,
User = user,
Product = product2,
StartTimeOfBooking = DateTime.Now.AddHours(oldStart),
EndTimeOfBooking = DateTime.Now.AddHours(oldEnd)
}
};
BookingOrder boBeforeCreated = new BookingOrder()
{
User = user,
Product = product,
StartTimeOfBooking = start,
EndTimeOfBooking = end
};
BookingOrder boAfterCreated = new BookingOrder()
{
Id = id,
User = user,
Product = product,
StartTimeOfBooking = start,
EndTimeOfBooking = end
};
_mockRepo.Setup(repo => repo.ReadAll()).Returns(bookingOrders);
_mockRepo.Setup(x => x.Create(boBeforeCreated)).Returns(boAfterCreated);
Assert.IsTrue(_service.Create(boBeforeCreated) != null);
_mockRepo.Verify(x => x.Create(It.IsAny <BookingOrder>()), Times.Once);
}
public async Task <int> Create(BlockingPlan model)
{
BlockingPlanLogic.CreateModel(model);
int created = await DbContext.SaveChangesAsync();
BookingOrder bookingOrder = await BookingOrderLogic.ReadModelById(model.BookingOrderId);
BookingOrderLogic.UpdateModelBlockingPlanId(bookingOrder.Id, bookingOrder, model.Id);
foreach (var workschedule in model.WorkSchedules)
{
await _weeklyPlanLogic.CreateByWeeklyplanItemByIdAndWeekId(workschedule);
}
await DbContext.SaveChangesAsync();
return(created);
}
public ActionResult <BookingAdapterOut> Get(int id)
{
try
{
BookingOrder booking = _bookingService.Read(id);
return(Ok(new BookingAdapterOut
{
Id = booking.Id,
Product = booking.Product,
User = booking.User,
StartTimeOfBooking = DateConverter.FromDatetimeToUTCEpoch(booking.StartTimeOfBooking),
EndTimeOfBooking = DateConverter.FromDatetimeToUTCEpoch(booking.EndTimeOfBooking)
}));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public static List <BookingOrder> GetOrdersInRange(string houseId, DateTime startDate, DateTime endDate)
{
return(SqlHelper.ExecuteReader(SP_ORDER_SELECT_IN_RANGE,
new[]
{
new SqlParameter("@houseId", houseId),
new SqlParameter("@startDate", startDate),
new SqlParameter("@endDate", endDate),
}, reader =>
{
var result = new List <BookingOrder>();
while (reader.Read())
{
var order = new BookingOrder
{
Id = reader["Id"].ToString(),
CheckinDate = DateTime.Parse(reader["CheckinDate"].ToString()),
CheckOutDate = DateTime.Parse(reader["CheckoutDate"].ToString()),
Note = reader["Note"]?.ToString() ?? string.Empty,
Status = reader["Status"].ToString(),
TotalGuest = int.Parse(reader["TotalGuest"].ToString()),
StayLength = reader["StayLength"].ToString(),
HouseId = reader["HouseId"].ToString(),
Rooms = new List <Room>()
};
result.Add(order);
}
reader.NextResult();
var mapping = result.ToDictionary(o => o.Id, o => o);
var rooms = RoomService.GetRooms(houseId);
var roomMapping = rooms.ToDictionary(r => r.Id, r => r);
while (reader.Read())
{
var order = mapping[reader["OrderId"].ToString()];
order.Rooms.Add(roomMapping[reader["RoomId"].ToString()]);
}
return result;
}));
}
public async Task <BookingOrder> PurchaseOrder(string cartId)
{
var cartItems = await database.BookingCartItemRepository.Filter(b => b.BookingCartId == cartId);
var firstCartItem = cartItems.FirstOrDefault();
if (firstCartItem == null)
{
return(null);
}
var orderDetails = new BookingOrderDetailsBuilder()
.SetOffer(firstCartItem.BookedDate.OfferId, firstCartItem.BookedDate.Offer.Title)
.SetBooking(firstCartItem.BookedDateId)
.OrderedByEmail(firstCartItem.User?.Email)
.From(firstCartItem.BookedDate.StartDate)
.To(firstCartItem.BookedDate.EndDate)
.SetLocation(firstCartItem.BookedDate.Offer.Location)
.SetContactData(firstCartItem.BookedDate.Offer.OfferDetails.PhoneNumber, firstCartItem.BookedDate.Offer.OfferDetails.EmailAddress)
.Build();
decimal totalPrice = cartItems.Sum(c => c.BookedDate.GetTotalPrice());
var order = BookingOrder.Create(Constants.BookingOrderDescription(orderDetails, totalPrice),
totalPrice);
database.BookingOrderRepository.Add(order);
if (!await database.Complete())
{
return(null);
}
orderDetails.SetOrderId(order.Id);
database.BookingOrderDetailsRepository.Add(orderDetails);
database.BookingCartItemRepository.DeleteRange(cartItems);
bookingService.ConfirmBookings(cartItems.Select(c => c.BookedDate));
return(await database.Complete() ? order : null);
}
public void TestBookingOrderServiceDeleteInvalidOparationExceptionNotDeleted(long id, int addStart, int addEnd)
{
DateTime start = DateTime.Now.AddHours(addStart);
DateTime end = DateTime.Now.AddHours(addEnd);
UserInfo user = new UserInfo();
Product product = new Product();
BookingOrder boBeforeCreated = new BookingOrder()
{
Id = id,
User = user,
Product = product,
StartTimeOfBooking = start,
EndTimeOfBooking = end
};
_mockRepo.Setup(x => x.Read(id)).Returns(boBeforeCreated);
_mockRepo.Setup(x => x.Delete(boBeforeCreated)).Returns(boBeforeCreated);
Assert.ThrowsException <InvalidOperationException>(() => _service.Delete(id));
_mockRepo.Verify(x => x.Delete(It.IsAny <BookingOrder>()), Times.Once);
}
public static ExternalCartAddOrderResult ExternalCart_AddOrder(string language, WebPartner partner, string externalCartId, BookingOrder order)
{
if (partner == null)
{
throw new System.ArgumentNullException("partner");
}
if (order == null)
{
throw new System.ArgumentNullException("order");
}
BookingClaim claim = new BookingClaim
{
orders = new System.Collections.Generic.List<BookingOrder>()
};
claim.orders.Add(order);
XElement xml = BookingProvider.BuildBookingClaimXml(partner.id, claim);
DataSet ds = DatabaseOperationProvider.QueryProcedure("up_guest_ExternalCart_AddOrder", "result", new
{
lang = language,
OrdersXML = xml,
CartId = externalCartId,
PartPass = partner.passId
});
return (
from DataRow row in ds.Tables["result"].Rows
select BookingProvider.factory.ExternalCartAddOrderResult(row)).FirstOrDefault<ExternalCartAddOrderResult>();
}
private static int GetFreePlacesForExcursion(BookingOrder order)
{
//call dbo.uf_CalcFreeExlimit(@Excurs int, @Date smalldatetime, @ExTime int, @Language int, @Region int)
var res = DatabaseOperationProvider.Query("SELECT [dbo].[uf_CalcFreeExlimit] (@ex, @date, @time, @lang, @reg)",
"services",
new { ex = order.excursion.id,
date = order.excursion.date.ToString("yyyy-MM-dd"),
time = order.excursion.extime,
lang = order.excursion.language,
reg = order.excursion.departure
});
int cnt = 1000;
foreach (DataRow row in res.Tables["services"].Rows)
try
{
cnt = Convert.ToInt32(row[0]);
}
catch (Exception ex)
{
Console.Write(ex.ToString());
return 1000;
}
return cnt;
}
