public static Point3d FirstAnchorRight(RoomPackage room)
{
var extentVal = 0.0;
var placementVal = 0.0;
var roomAxisY = room.OrientationPlane.YAxis;
var roomAxisX = room.OrientationPlane.XAxis;
if (Confirm.VectorProportionIsVertical(roomAxisY))
{
extentVal = roomAxisY.Y > 0 ? room.Dims.YMax : room.Dims.YMin;
placementVal = roomAxisX.X > 0 ? room.Dims.XMax : room.Dims.XMin;
room.Rex = placementVal;
return(new Point3d(placementVal, extentVal, 0));
}
else
{
extentVal = roomAxisY.X > 0 ? room.Dims.XMax : room.Dims.XMin;
placementVal = roomAxisX.Y > 0 ? room.Dims.YMax : room.Dims.YMin;
room.Rex = placementVal;
return(new Point3d(extentVal, placementVal, 0));
}
}
public static void RemainingProgramTargets(ZonePackage zone, RoomPackage room)
{
for (int i = 0; i < room.NumProgramsPlaced.Count; i++)
{
zone.RemainingProgramTargets[i] = zone.RemainingProgramTargets[i] - room.NumProgramsPlaced[i];
}
}
public static void MaximumPlacements(RoomPackage room, ZonePackage zone, ProgramManifest pm)
{
var maxPlacement = room.FillOrder
.Select(x => pm.ProgramPackages[x].Quota == 0 ? 999 : zone.RemainingProgramTargets[x]).ToList();
room.MaxPlacement = maxPlacement;
}
/// <summary>
/// Stages program in center of room. Distorts plane alignment, so only useful for debugging.
/// </summary>
/// <param name="room"></param>
/// <param name="program"></param>
/// <returns></returns>
public static PlacementPackage CenteredInRoom(RoomPackage room, ProgramPackage program)
{
var roomPlane = room.OrientationPlane;
var newBounds = new Rectangle3d(roomPlane, new Interval(program.Dims.Width / -2, program.Dims.Width / 2), new Interval(program.Dims.Height / -2, program.Dims.Height / 2)).ToNurbsCurve();
return(new PlacementPackage(program, roomPlane, newBounds));
}
public ActionResult DeleteConfirmed(int id)
{
RoomPackage roomPackage = db.RoomPackage.Find(id);
db.RoomPackage.Remove(roomPackage);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Stages program with its base plane location and orientation aligned to room's.
/// </summary>
/// <param name="room"></param>
/// <param name="program"></param>
/// <returns></returns>
public static PlacementPackage InRoom(RoomPackage room, ProgramPackage program)
{
var roomPlane = new Plane(room.OrientationPlane);
var newBounds = new Rectangle3d(roomPlane, new Interval(0, program.Dims.Width), new Interval(0, program.Dims.Height * -1)).ToNurbsCurve();
return(new PlacementPackage(program, roomPlane, newBounds));
}
public static PlacementPackage ForFrontRow(RoomPackage room, PlacementPackage program)
{
Transform move = Transform.Translation(room.BaseAnchorLeft - room.OrientationPlane.Origin);
program.Bounds.Transform(move);
var stagedPlane = new Plane(room.BaseAnchorLeft, new Vector3d(room.OrientationPlane.XAxis), new Vector3d(room.OrientationPlane.YAxis));
return(new PlacementPackage(program.Program, stagedPlane, program.Bounds));
}
public ActionResult Edit([Bind(Include = "roomPackageID,namePackage,price,roomTypeID,frequency")] RoomPackage roomPackage)
{
if (ModelState.IsValid)
{
db.Entry(roomPackage).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.roomTypeID = new SelectList(db.RoomType, "roomTypeID", "typeName", roomPackage.roomTypeID);
return(View(roomPackage));
}
/// <summary>
/// Population routine for debugging. Places one instance of highest priority item in room.
/// </summary>
/// <param name="room"></param>
/// <param name="zone"></param>
/// <param name="pm"></param>
public static void PlaceOne(RoomPackage room, ZonePackage zone, ProgramManifest pm)
{
var firstWithTarget = pm.ProgramPackages[zone.ProgramTargets.IndexOf(zone.ProgramTargets.First(x => x > 0))];
var candidate = Stage.Program.InRoom(room, firstWithTarget);
if (Collision.PlacementIsValid(room, candidate, pm))
{
room.PlacedItems.Add(candidate);
room.NumProgramsPlaced[firstWithTarget.Priority] = room.NumProgramsPlaced[firstWithTarget.Priority] + 1;
}
}
/// <summary>
/// Basic collision detection routine for single item placement.
/// </summary>
/// <param name="room">Room currently being populated.</param>
/// <param name="candidate">PlacementPackaged being checked for fidelity.</param>
/// <param name="pm"></param>
/// <returns></returns>
public static bool PlacementIsValid(RoomPackage room, PlacementPackage candidate, ProgramManifest pm)
{
//Verify placed item does not clash with previously placed items.
foreach (PlacementPackage placedItem in room.PlacedItems)
{
if (Confirm.CurvesIntersect(placedItem.Bounds, candidate.Bounds, true))
{
if (Confirm.CurvesIntersect(placedItem.Bounds, candidate.Bounds, false))
{
return(false);
}
CurveIntersections ccx = Intersection.CurveCurve(placedItem.Bounds, candidate.Bounds, 0.1, 0.1);
if (ccx.Count(x => x.IsOverlap) > 1)
{
return(false);
}
}
PointContainment insideCheck = placedItem.Bounds.Contains(candidate.Bounds.GetBoundingBox(Plane.WorldXY).Center);
if (insideCheck == PointContainment.Inside || insideCheck == PointContainment.Coincident)
{
return(false);
}
}
//Verify item is completely within boundary of room.
foreach (Curve edgeCurve in room.AllEdgeCurves)
{
if (Confirm.CurvesIntersect(candidate.Bounds, edgeCurve, false))
{
return(false);
}
/*
* if (!Confirm.PointInRegion(room.Region, new CurveBounds(candidate.Bounds).Center))
* {
* return false;
* }
*/
}
//Verify program area is not larger than total room area.
if (room.Region.GetArea() < pm.ProgramPackages[candidate.ProgramIndex].OccupationArea)
{
return(false);
}
return(true);
}
public static void ProgramFillOrder(RoomPackage room, ZonePackage zone, ProgramManifest pm)
{
var fillOrder = Enumerable.Range(0, zone.RemainingProgramTargets.Count)
.Where(i => zone.RemainingProgramTargets[i] > 0 && pm.ProgramPackages[i].Quota != 0).ToList()
.Select(x => pm.ProgramPackages[x])
.OrderByDescending(x => x.Dims.Height).ToList()
.Select(x => x.Priority).ToList();
fillOrder.AddRange(pm.ProgramPackages
.Where(x => x.Quota == 0).ToList()
.Select(x => x.Priority));
room.FillOrder = fillOrder;
}
public static PlacementPackage ForRightLane(RoomPackage room, PlacementPackage program)
{
//Rotate item and move it to starting point.
program.Bounds.Rotate(Math.PI / -2, Vector3d.ZAxis, room.OrientationPlane.Origin);
var shiftDir = new Vector3d(room.OrientationPlane.YAxis);
shiftDir.Reverse();
shiftDir = shiftDir * (program.Program.Dims.Width / shiftDir.Length);
Transform shift = Transform.Translation(shiftDir);
Transform move = Transform.Translation(room.BaseAnchorRight - room.OrientationPlane.Origin);
program.Bounds.Transform(shift);
program.Bounds.Transform(move);
//Identify new orientation plane's origin.
var roomIsVertical = Math.Abs(room.OrientationPlane.YAxis.Y) > Math.Abs(room.OrientationPlane.YAxis.X);
Point3d origin;
if (roomIsVertical)
{
origin = room.OrientationPlane.YAxis.Y > 0 ? new Point3d(room.BaseAnchorRight.X, room.BaseAnchorRight.Y - program.Program.Dims.Width, 0) : new Point3d(room.BaseAnchorRight.X, room.BaseAnchorRight.Y + program.Program.Dims.Width, 0);
}
else
{
origin = room.OrientationPlane.YAxis.X > 0 ? new Point3d(room.BaseAnchorRight.X - program.Program.Dims.Width, room.BaseAnchorRight.Y, 0) : new Point3d(room.BaseAnchorRight.X + program.Program.Dims.Width, room.BaseAnchorRight.Y, 0);
}
//Generate new base plane.
var stagedPlane = new Plane(origin, shiftDir, new Vector3d(room.OrientationPlane.XAxis));
//Confirm item is still in zone. If not, compensate.
if (Confirm.PointInRegion(room.Region, new CurveBounds(program.Bounds).Center, 0.1))
{
return(new PlacementPackage(program.Program, stagedPlane, program.Bounds));
}
//Generate mirror plane and reflect bounds.
var mirrorPlane = new Plane(room.OrientationPlane);
mirrorPlane.Rotate(Math.PI / 2, mirrorPlane.YAxis);
mirrorPlane.Origin = room.BaseAnchorRight;
Transform mirror = Transform.Mirror(mirrorPlane);
program.Bounds.Transform(mirror);
return(new PlacementPackage(program.Program, stagedPlane, program.Bounds));
}
// GET: RoomPackages/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
RoomPackage roomPackage = db.RoomPackage.Find(id);
if (roomPackage == null)
{
return(HttpNotFound());
}
return(View(roomPackage));
}
// GET: RoomPackages/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
RoomPackage roomPackage = db.RoomPackage.Find(id);
if (roomPackage == null)
{
return(HttpNotFound());
}
ViewBag.roomTypeID = new SelectList(db.RoomType, "roomTypeID", "typeName", roomPackage.roomTypeID);
return(View(roomPackage));
}
/// <summary>
/// Selects best population strategy for room based on current conditions.
/// </summary>
/// <param name="room"></param>
/// <param name="zone"></param>
/// <param name="pm"></param>
public static void Room(RoomPackage room, ZonePackage zone, ProgramManifest pm)
{
//Prepare room for population routine based on current fill progress.
room.PlacedItems = new List <PlacementPackage>();
Stage.Room.BaseAnchors(room);
Stage.Room.ProgramFillOrder(room, zone, pm);
Stage.Room.MaximumPlacements(room, zone, pm);
//Select best population strategy based on room geometry and quotas.
//TODO: Automate selection process and write base suite of strategies.
Populate.ByMostRows(room, zone, pm);
//After room is filled, adjust remaining quota for zone.
Update.Zone.RemainingProgramTargets(zone, room);
}
public static Point3d NextAnchorRows(RoomPackage room, ProgramPackage program, Point3d anchor, double multiplier, double buffer)
{
var step = 0.0;
if (Confirm.VectorProportionIsVertical(room.OrientationPlane.YAxis))
{
step = room.OrientationPlane.YAxis.Y > 0 ? program.Dims.Width * -1 : program.Dims.Width;
step = (step * multiplier) + buffer;
return(new Point3d(anchor.X, anchor.Y + step, 0));
}
else
{
step = room.OrientationPlane.YAxis.X > 0 ? program.Dims.Width * -1 : program.Dims.Width;
step = (step * multiplier) + buffer;
return(new Point3d(anchor.X + step, anchor.Y, 0));
}
}
/// <summary>
/// Generates a base plane for each room with +Y pointing towards circulation.
/// Necessary to normalize placement of program across highly varied room geometry.
/// </summary>
/// <param name="room"></param>
/// <param name="zone"></param>
public static void Orientation(RoomPackage room, ZonePackage zone)
{
var circEdge = Select.PrimaryCirculationEdge(zone);
var basePoint = Utils.GetRegionCenter(room.Region);
circEdge.ClosestPoint(basePoint, out double t);
var circEdgePoint = circEdge.PointAt(t);
var yDirVector = new Vector3d(circEdgePoint - basePoint);
var yTestVal = Confirm.VectorProportionIsVertical(yDirVector) ? yDirVector.Y : yDirVector.X;
var yAxis = Confirm.VectorProportionIsVertical(yDirVector) ? new Vector3d(0, yTestVal, 0) : new Vector3d(yTestVal, 0, 0);
var xAxis = new Vector3d(yAxis);
xAxis.Rotate(Math.PI / 2, Vector3d.ZAxis);
var roomOrientationPlane = new Plane(basePoint, xAxis, yAxis);
room.OrientationPlane = roomOrientationPlane;
}
/// <summary>
/// Populates room in rows along its Y axis. Packs along the left (-X) edge until passing the room's midpoint, then packs along right edge until full.
/// </summary>
/// <param name="room"></param>
/// <param name="zone"></param>
/// <param name="pm"></param>
public static void ByMostRows(RoomPackage room, ZonePackage zone, ProgramManifest pm)
{
var lexFull = false;
var rexFull = false;
var openZones = !lexFull || !rexFull;
var anchor = Point3d.Unset;
//Parent population method.
while (room.MaxPlacement.Select(x => x > 0).Any() && openZones)
{
//Iterate through programs as staged.
// (Chuck) Important: room.MaxPlacement aligns to program indices in room.FillOrder.
// These DO NOT align to pm.ProgramPackages, and often don't even contain all programs.
// To get data for the active program from its ProgramPackage, or to use a list that aligns with it, reference with index at room.FillOrder[i].
for (int i = 0; i < room.MaxPlacement.Count; i++)
{
var activeProgram = pm.ProgramPackages[room.FillOrder[i]];
var activeProgramIndex = room.FillOrder[i];
//Begin packing program.
while (room.MaxPlacement[i] - room.NumProgramsPlaced[activeProgramIndex] > 0)
{
PlacementPackage candidate = null;
//Start in left half.
if (!lexFull)
{
candidate = Stage.Program.ForLeftLane(room, Stage.Program.InRoom(room, activeProgram));
//Move candidate to next position.
anchor = room.NextAnchor == Point3d.Unset ? room.BaseAnchorLeft : room.NextAnchor;
candidate.Bounds.Transform(Transform.Translation(anchor - room.BaseAnchorLeft));
//Verify that placement is valid and stage next anchor point accordingly.
if (Collision.PlacementIsValid(room, candidate, pm))
{
room.PlacedItems.Add(candidate);
room.NumProgramsPlaced[activeProgramIndex]++;
candidate.Dims = new CurveBounds(candidate.Bounds);
candidate.Orientation.Origin.Transform(Transform.Translation(anchor - room.BaseAnchorLeft));
var buffer = 0.0;
if (candidate.Program.AccessDirections == "1111")
{
buffer = 3;
}
room.PrevAnchor = anchor;
room.NextAnchor = Stage.Room.NextAnchorRows(room, activeProgram, anchor, 1, buffer);
}
//Otherwise shift anchor slightly and retry.
else
{
room.PrevAnchor = anchor;
room.NextAnchor = Stage.Room.NextAnchorRows(room, activeProgram, anchor, 1, 0.1);
}
if (!Confirm.PointInRegion(room.Region, room.NextAnchor))
{
if (i == room.MaxPlacement.Count - 1)
{
room.NextAnchor = Point3d.Unset;
lexFull = true;
break;
}
room.NextAnchor = Point3d.Unset;
break;
}
continue;
}
if (!rexFull)
{
candidate = Stage.Program.ForRightLane(room, Stage.Program.InRoom(room, activeProgram));
//Move candidate to next position.
anchor = room.NextAnchor == Point3d.Unset ? room.BaseAnchorRight : room.NextAnchor;
candidate.Bounds.Transform(Transform.Translation(anchor - room.BaseAnchorRight));
//Verify that placement is valid and stage next anchor point accordingly.
if (Collision.PlacementIsValid(room, candidate, pm))
{
room.PlacedItems.Add(candidate);
room.NumProgramsPlaced[activeProgramIndex]++;
candidate.Dims = new CurveBounds(candidate.Bounds);
candidate.Orientation.Origin.Transform(Transform.Translation(anchor - room.BaseAnchorRight));
var buffer = 0.0;
if (candidate.Program.AccessDirections == "1111")
{
buffer = 3;
}
room.PrevAnchor = anchor;
room.NextAnchor = Stage.Room.NextAnchorRows(room, activeProgram, anchor, 1, buffer);
}
//Otherwise shift anchor slightly and retry.
else
{
room.PrevAnchor = anchor;
room.NextAnchor = Stage.Room.NextAnchorRows(room, activeProgram, anchor, 1, 0.1);
}
if (!Confirm.PointInRegion(room.Region, room.NextAnchor))
{
if (i == room.MaxPlacement.Count - 1)
{
room.NextAnchor = Point3d.Unset;
rexFull = true;
break;
}
room.NextAnchor = Point3d.Unset;
break;
}
continue;
}
openZones = false;
break;
}
//Room has been populated.
}
}
}
public static void OrientForRoom(Curve crv, PlacementPackage item, RoomPackage room)
{
crv.Transform(Transform.Rotation(Vector3d.YAxis, room.OrientationPlane.XAxis, item.Dims.Center));
}
public List <HotelChannelResult> MapSearchResult(List <Hotel> searchOutputs, SearchData searchData)
{
try
{
//save result
//apply salesRules
List <HotelChannelResult> searchResponse = new List <HotelChannelResult>();
CurrencyManager currencyManager = new CurrencyManager();
SalesRulesManager ServiceChargeManager = new SalesRulesManager();
SalesRulesManager CancellationChargeManager = new SalesRulesManager();
var BaseCur = ConfigurationSettings.AppSettings["BaseCur"];
//start sales rules service charge
ServiceChargeManager.FillSalesRules(searchData.POS, "Hotel", "Service Charge"); //1
ServiceChargeManager.PrepareSearchCriteriaDic(searchData); //2
////
/////cancellation charge
CancellationChargeManager.FillSalesRules(searchData.POS, "Hotel", "Cancellation Charge");
CancellationChargeManager.PrepareSearchCriteriaDic(searchData);
//
List <string> hotelIds = searchOutputs.Select(a => a.code.ToString()).ToList();
HotelManager manager = new HotelManager();
List <HotelDetails> HotelDataList = manager.GetChannelHotelData(hotelIds, "4");
// List<HotelSearchResult> results = new List<HotelSearchResult>();
double ProviderExcahngeRate = currencyManager.GetCurrencyConversion(searchOutputs[0].currency, BaseCur, searchData.sID);
/////double ProviderExcahngeRate = currencyManager.GetCurrencyConversion("EUR", BaseCur);
double ExcahngeRate = currencyManager.GetCurrencyConversion(BaseCur, searchData.Currency, searchData.sID);
///// searchResponse.Locations = HotelDataList.GroupBy(x => x.Location).Select(x => x.FirstOrDefault()).Select(a=>a.Location).ToList();
int duration = Convert.ToInt32((searchData.DateTo - searchData.DateFrom).TotalDays);
{
DateTime CheckInDate = searchData.DateFrom;
for (int i = 0; i < searchOutputs.Count; i++)
{
HotelDetails hotelData = HotelDataList.Where(a => a.ProviderHotelId == searchOutputs[i].code.ToString()).FirstOrDefault();
HotelChannelResult hotel = new HotelChannelResult();
if (hotelData != null)
{
hotel.providerHotelCode = searchOutputs[i].code.ToString();
hotel.providerID = "4";
hotel.providerHotelID = hotelData.ProviderHotelId;
hotel.hotelId = hotelData.ID.ToString();
hotel.sellCurrency = searchData.Currency;
// hotel.costPrice =//Math.Round( (double.Parse(searchOutputs[i].price.net.Value.ToString()) * ProviderExcahngeRate) /duration,3);
hotel.costCurrency = searchOutputs[i].currency;
hotel.DeepLink = "http://93.115.27.156:3030/api/WegoHotelSearch?sid=" + searchData.sID + "&hotelId=" + hotelData.HotelId + "&pid=4";
CancellationChargeManager.SetResultCriteria(hotelData.HotelName, int.Parse(hotelData.Rating), hotel.costPrice, "4");
AppliedSalesRule AppliedCancellationMarkup = CancellationChargeManager.ApplySalesRules("Markup");
int roomcount = 0;
int Packagecount = 0;
for (int j = 0; j < searchOutputs[i].rooms.Count; j++)
{
if (Packagecount == 20)
{
}
RoomPackages roomPackage = new RoomPackages();
List <ChannelRoomsRate> roomsRate = new List <ChannelRoomsRate>();
roomPackage.RoomCategory = searchOutputs[i].rooms[j].name;
List <RoomPackage> Containers = new List <RoomPackage>();
for (int r = 0; r < searchData.SearchRooms.Count; r++)
{
ChannelRoomsRate roomRate = new ChannelRoomsRate();
/* var rooms = searchOutputs[i].rooms[j].rates.GroupBy(c => new
* {
* c.adults,
* c.children,
* }).Select(c => c.Where(a=>a.adults== searchData.SearchRooms[r].Adult &&a.children== searchData.SearchRooms[r].Child.Count).ToList());
*/
var rooms = searchOutputs[i].rooms[j].rates.Where(a => a.adults == searchData.SearchRooms[r].Adult && a.children == searchData.SearchRooms[r].Child.Count).GroupBy(p => p.rateKey).Select(grp => grp.FirstOrDefault()).ToList();
if (rooms.Count > 0)
{
roomRate.RoomRates.AddRange(rooms);
roomsRate.Add(roomRate);
}
else
{
var roomnames = searchOutputs[i].rooms[j].name.Split(' ');
// var key = roomnames[roomnames.Length-1];
int indexToRemove = 0;
roomnames = roomnames.Where((source, index) => index != indexToRemove).ToArray();
var key = string.Join(" ", roomnames);
var roomstype = searchOutputs[i].rooms.Where(a => a.name.Contains(key));
foreach (var item in roomstype)
{
var lstroom = item.name.Split(' ');
int index1ToRemove = 0;
lstroom = lstroom.Where((source, index) => index != index1ToRemove).ToArray();
var key1 = string.Join(" ", lstroom);
if (key == key1)
{
var RoomsSameType = item.rates.Where(a => a.adults == searchData.SearchRooms[r].Adult && a.children == searchData.SearchRooms[r].Child.Count).GroupBy(p => p.rateKey).Select(grp => grp.FirstOrDefault()).ToList();
if (RoomsSameType.Count > 0)
{
roomRate.RoomRates.AddRange(RoomsSameType);
roomsRate.Add(roomRate);
}
}
}
}
if (roomRate.RoomRates.Count == 0)
{
roomsRate = new List <ChannelRoomsRate>();
break;
}
}
int max = 0;
if (roomsRate.Count > 0)
{
max = roomsRate.Max(r => r.RoomRates.Count);
}
for (int ra = 0; ra < max; ra++)
{
RoomPackage Container = new RoomPackage();
double sellPerNight = 0;
double sellPerAll = 0;
List <RoomResult> resultsPackage = new List <RoomResult>();
foreach (var item in roomsRate)
{
int indx = ra;
if (ra >= item.RoomRates.Count)
{
indx = item.RoomRates.Count - 1;
}
RoomResult room = new RoomResult();
room.PackageNO = Packagecount + 1;
if (item.RoomRates[indx].net == null)
{
continue;
}
room.CostPrice = Math.Round(double.Parse(item.RoomRates[indx].net), 3);
ServiceChargeManager.SetResultCriteria(hotelData.HotelName, int.Parse(hotelData.Rating), room.CostPrice
* ProviderExcahngeRate, "4");
AppliedSalesRule AppliedMarkup = ServiceChargeManager.ApplySalesRules("Markup");
AppliedSalesRule AppliedDiscount = ServiceChargeManager.ApplySalesRules("Discount");
// room.IsRefundable = searchOutputs[i].rooms[j].refundable;
////******
room.RatePerNight = ((room.CostPrice * ProviderExcahngeRate / duration) + AppliedMarkup.Value - AppliedDiscount.Value) * ExcahngeRate;
room.RatePerNight = Math.Round(room.RatePerNight, 3);
sellPerNight += room.RatePerNight;
room.TotalSellPrice = Math.Round(room.RatePerNight * duration, 3);
sellPerAll += room.TotalSellPrice;
roomcount += 1;
room.RoomIndex = roomcount;
room.RoomReference = item.RoomRates[indx].rateKey;
/////
room.RoomCode = searchOutputs[i].rooms[j].code;
/////////
room.RoomType = searchOutputs[i].rooms[j].name;
///////
room.RoomMeal = item.RoomRates[indx].boardName;
room.Adult = item.RoomRates[indx].adults;
room.Child = item.RoomRates[indx].children;
room.IsRefundable = item.RoomRates[indx].rateClass == "NRF" ? false : true;
///////
room.Paxs = item.RoomRates[indx].adults + item.RoomRates[indx].children;
//*** room.Images = hotelData.Images.Where(a => a.Category.ToLower() == "hotel rooms").Select(a => a.Url).ToList();
room.DiscountId = AppliedDiscount.ID;
room.MarkupId = AppliedMarkup.ID;
room.DiscountValue = AppliedDiscount.Value * ExcahngeRate;
room.MarkupValue = AppliedMarkup.Value * ExcahngeRate;
room.cancellationRules = item.RoomRates[indx].cancellationPolicies == null ? new List <CancellationRule>()
{
new CancellationRule {
Cost = 0, Price = 0, CanellationRuleText = null, FromDate = null, ToDate = null
}
} :
item.RoomRates[indx].cancellationPolicies.Select(a => new CancellationRule
{
Price = Math.Round(((double.Parse(a.amount) * ProviderExcahngeRate) + AppliedCancellationMarkup.Value) * ExcahngeRate, 3),
CanellationRuleText = searchData.Lang.ToLower() == "en" ? Math.Round(((double.Parse(a.amount) * ProviderExcahngeRate) + AppliedCancellationMarkup.Value) * ExcahngeRate, 3) + "" + searchData.Currency + " To " + a.from : a.from + " إلى " + "" + searchData.Currency + Math.Round(((double.Parse(a.amount) * ProviderExcahngeRate) + AppliedCancellationMarkup.Value) * ExcahngeRate, 3),
Cost = Math.Round(double.Parse(a.amount)),
FromDate = a.from.ToString()
}).ToList();
resultsPackage.Add(room);
}
Container.No = Packagecount + 1;
Container.PricePerNight = sellPerNight;
Container.PricePerAllNight = sellPerAll;
Container.roomResults.AddRange(resultsPackage);
Containers.Add(Container);
Packagecount += 1;
}
roomPackage.roomPackages.AddRange(Containers);
hotel.packages.Add(roomPackage);
}
double MinPerNight = 0;
double MinperAll = 0;
var mindata = hotel.packages[0].roomPackages.Where(a => a.PricePerAllNight == hotel.packages[0].roomPackages.Min(x => x.PricePerAllNight)).FirstOrDefault();
if (mindata != null)
{
MinperAll = mindata.PricePerAllNight;
MinPerNight = mindata.PricePerNight;
}
foreach (var item in hotel.packages)
{
var minPackage = item.roomPackages.Where(a => a.PricePerAllNight == item.roomPackages.Min(x => x.PricePerAllNight)).FirstOrDefault();
if (minPackage != null)
{
if (minPackage.PricePerAllNight < MinperAll)
{
MinperAll = minPackage.PricePerAllNight;
MinPerNight = minPackage.PricePerNight;
}
}
}
// var minRoom = hotel.rooms.Where(a => a.RatePerNight == hotel.rooms.Min(x => x.RatePerNight)).FirstOrDefault();
if (MinperAll > 0)
{
hotel.PricePerNight = MinPerNight;
// hotel.costPrice = minRoom.CostPrice;
hotel.PricePerAllNight = MinperAll;
}
searchResponse.Add(hotel);
}
}
// searchResponse.HotelResult = results;
return(searchResponse);
}
}
catch (Exception ex)
{
LoggingHelper.WriteToFile("MapSearchResultChannel/Errors/", "MapSearchResult_" + searchData.sID, ex.Message, ex.Message + " Sourse :" + ex.Source + " Stack Trace :" + ex.StackTrace);
return(new List <HotelChannelResult>());
}
}
/// <summary>
/// Container method for legibility in the staging method that references it.
/// These methods determine the top left, right, and center points of a room based on its orientation.
/// </summary>
/// <param name="room"></param>
public static void BaseAnchors(RoomPackage room)
{
room.BaseAnchorLeft = Stage.Room.FirstAnchorLeft(room);
room.BaseAnchorCenter = Stage.Room.FirstAnchorCenter(room);
room.BaseAnchorRight = Stage.Room.FirstAnchorRight(room);
}
/// <summary>
/// Populate room by marching along perimeter. Generate interior islands as necessary.
/// </summary>
/// <param name="room"></param>
/// <param name="zone"></param>
/// <param name="pm"></param>
public static void ByPerimeter(RoomPackage room, ZonePackage zone, ProgramManifest pm)
{
//TODO: Write this routine. Must solve lane generation problems for curvilinear zones first.
}
public HotelPackagesDetails GetHotelPackages(string pid, string sid, string hid)
{
HotelPackagesDetails hotelPackages = new HotelPackagesDetails();
SearchDBEntities searchDB = new SearchDBEntities();
hotelsDBEntities hotelsDB = new hotelsDBEntities();
var hotelSearchData = hotelsDB.hotels.FirstOrDefault(a => a.hotelID == hid);
var hotelSearchpro = hotelsDB.hotelsProviders.FirstOrDefault(a => a.hotelID == hotelSearchData.ID.ToString() && a.providerID == pid);
var hotelSearchDesc = hotelsDB.HotelsDescriptions.FirstOrDefault(a => a.hotelID == hid);
var Imgs = hotelsDB.HotelsImages.Where(a => a.HotelID == hid).ToList();
List <string> images = Imgs.Select(x => x.URL).ToList();
hotelPackages.providerHotelID = hotelSearchpro.providerHotelID;
hotelPackages.hotelCode = hotelSearchData.hotelID;
hotelPackages.Address = hotelSearchData.address;
hotelPackages.Lng = hotelSearchData.Lng;
hotelPackages.Lat = hotelSearchData.Lat;
hotelPackages.hotelStars = int.Parse(hotelSearchData.rating);//
hotelPackages.hotelName = hotelSearchData.hotelName;
hotelPackages.providerID = hotelSearchpro.providerID;
hotelPackages.Location = hotelSearchData.location;
hotelPackages.hotelDescription = hotelSearchDesc.Description1;
hotelPackages.shortcutHotelDescription = hotelSearchDesc.Description2;
hotelPackages.City = hotelSearchData.cityName;
hotelPackages.Country = hotelSearchData.countryName;
hotelPackages.hotelImages = images;
var packages = searchDB.HotelPackages.Where(a => a.Session == sid && a.Hotelid == hid && a.Provider.ToString() == pid).ToList();
var Rooms = searchDB.SearchRoomResults.Where(a => a.sID == sid && a.HotelCode == hid && a.ProviderId.ToString() == pid).ToList();
RoomPackages roomPackage = new RoomPackages();
foreach (var item in packages)
{
// var availableCate = hotelPackages.packages.FirstOrDefault(a => a.RoomCategory == item.Category);
if (roomPackage.RoomCategory != item.Category)
{
if (roomPackage.roomPackages.Count != 0)
{
roomPackage.PackagesNo = roomPackage.roomPackages.Count;
hotelPackages.packages.Add(roomPackage);
}
roomPackage = new RoomPackages();
roomPackage.RoomCategory = item.Category;
}
RoomPackage roomPack = new RoomPackage();
roomPack.No = item.PackageNum.Value;
roomPack.PricePerAllNight = item.PricePerAllNight.Value;
roomPack.PricePerNight = item.PricePerNight.Value;
var specPack = Rooms.Where(x => x.PackageNo == item.PackageNum).ToList();
foreach (var r in specPack)
{
RoomResult result = new RoomResult();
result.CostPrice = r.costPrice.Value;
result.DiscountId = r.DiscountId.Value;
result.PackageNO = r.PackageNo.Value;
result.DiscountValue = r.DiscountVal.Value;
result.Images = Imgs.Where(x => x.Category.ToLower() == "hotel rooms").Select(a => a.URL).ToList();
result.MarkupId = r.MarkupId.Value;
result.MarkupValue = r.MarkupVal.Value;
result.Paxs = r.PaxSQty.Value;
result.RoomCode = r.roomType;
result.RoomIndex = int.Parse(r.RoomCode);
result.RoomMeal = r.meal;
result.RoomReference = r.RoomReference;
result.RoomType = r.RoomName;
result.TotalSellPrice = r.SellPrice.Value;
result.Adult = r.Adults.Value;
result.Child = r.Childern.Value;
if (r.IsRefundable.Value != null)
{
result.IsRefundable = r.IsRefundable.Value;
}
roomPack.roomResults.Add(result);
}
roomPackage.roomPackages.Add(roomPack);
//hotelPackages.packages.Add(roomPackage);
}
if (roomPackage.roomPackages.Count != 0)
{
hotelPackages.packages.Add(roomPackage);
}
return(hotelPackages);
}
/// <summary>
/// Extracts indices of programs each lane was "designed for" during Update.Room.LaneConfiguration.
/// </summary>
/// <param name="room"></param>
/// <param name="zone"></param>
/// <param name="i"></param>
public static void ProgramHint(RoomPackage room, ZonePackage zone, int i)
{
room.ProgramHint = i >= zone.LanePackages.Count ? new List <int>() : zone.LanePackages[i].Programs;
}
