public async Task <IActionResult> SaveResponse([FromServices] ISurveyResponses surveyResponse, SummaryModel summaryModel)
{
if (!ModelState.IsValid)
{
return(RedirectToAction(SummaryTag));
}
Address address = new Address(
summaryModel.Address.Address1,
summaryModel.Address.Address2,
summaryModel.Address.Town,
summaryModel.Address.County,
summaryModel.Address.Postcode);
LightingSurvey survey = new LightingSurvey(
summaryModel.Name.FullName,
summaryModel.Email.Email,
address,
summaryModel.LightingLevel.HappyWithLightingLevel.Value,
summaryModel.Brightness.BrightnessLevel.Value);
int reference = await surveyResponse.SaveSurveyResponse(survey);
TempData.Clear();
ConfirmationModel confirmationModel = new ConfirmationModel();
confirmationModel.Id = reference;
return(RedirectToAction("Confirmation", confirmationModel));
}
public ActionResult ConfirmManually(ConfirmationModel model)
{
if (ModelState.IsValid)
{
User user = AccountServices.FindUser(usr => usr.Username == model.UserName);
if (user == null)
{
ModelState.AddModelError("UserName", Resources.AppMessages.Error_User_Not_Exist);
return(View(model));
}
else
{
if (user.IsConfirmed)
{
ModelState.AddModelError("UserName", Resources.AppMessages.Error_User_Confirmed_Yet);
return(View(model));
}
}
if (CodeFirstSecurity.ConfirmAccount(model.Token) == false)
{
ModelState.AddModelError("Token", Resources.AppMessages.Error_ConfirmationToken);
}
else
{
FormsAuthentication.SetAuthCookie(model.UserName, false);
return(RedirectToRoute("Default", new { controller = "Account", action = "RegistrationSuccesfull" }));
}
}
return(View());
}
public ConfirmationDialog()
{
InitializeComponent();
ModelServiceLocator serviceLocator = this.FindResource <ModelServiceLocator>("serviceLocator");
this.model = serviceLocator.ConfirmationModel;
}
public async Task <IActionResult> Confirm(ConfirmationModel model)
{
if (!ModelState.IsValid)
{
// If we got this far, something failed, redisplay form
return(await Task.FromResult(View()));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
ModelState.AddModelError("NotFound", "User with the email addres provided was not found");
return(await Task.FromResult(View(model)));
}
var confirmSignup = await _userManager.ConfirmSignUpAsync(user, model.Code, true);
if (!confirmSignup.Succeeded)
{
foreach (var error in confirmSignup.Errors)
{
ModelState.AddModelError(error.Code, error.Description);
}
return(await Task.FromResult(View(model)));
}
return(RedirectToAction("Index", "Home"));
}
public ConfirmationModel Checkout(UserInfoModel model)
{
int carId = 0;
string rentalId = "";
ConfirmationModel confirmationModel = null;
// bool IsBookingConfirmed = false;
using (var entity = new online_resEntities())
{
var carsBookedForOverlap = from r in entity.CarRental
where !(r.BookingStartdate <= model.BookingModel.EndDate && model.BookingModel.StartDate <= r.BookingStartdate)
select r.CarId;
//carId = entity.Car.FirstOrDefault(i => i.CategoryType.ToLower() == model.CarAvailabiltyModel.Name.ToLower()).CarId;
carId = entity.Car.Where(o => !carsBookedForOverlap.Contains(o.CarId)).FirstOrDefault(i => i.CategoryType.ToLower() == model.CarAvailabiltyModel.Name.ToLower()).CarId;
//carId = (from car in entity.Car
// where car.CategoryType.ToLower() == model.CarAvailabiltyModel.Name.ToLower() && !carsBookedForOverlap.Contains(car.CarId)
// select car.CarId).FirstOrDefault();
rentalId = GetNewRentalId(carId);
//check if user exist or else create it
var user = entity.Customer.FirstOrDefault(o => o.Username.ToLower() == model.EmailId);
if (user == null)
{
var newCustomer = new Customer
{
Username = model.EmailId,
Dob = DateTime.Now.AddYears(-23),
Firstname = model.FirstName,
Lastname = model.LastName,
License = model.LicenseNumber
};
entity.Customer.Add(newCustomer);
entity.SaveChanges();
}
var newRental = new CarRental
{
//RentalId = Convert.ToInt32(rentalId),
CarId = carId,
BookingEnddate = model.BookingModel.EndDate,
BookingStartdate = model.BookingModel.StartDate,
LocationName = model.BookingModel.Location,
Username = model.EmailId,
Dropoff = "empty",
Pickup = "empty",
};
entity.CarRental.Add(newRental);
entity.SaveChanges();
confirmationModel = new ConfirmationModel {
UserModel = model, BookingNumber = bookingPrefix + rentalId, IsBookingConfirmed = true
};
}
return(confirmationModel);
}
public ActionResult ResendConfirmation(ConfirmationModel model)
{
if (verification.ResendRegistrationEmail(model.Email))
{
return(this.RedirectToAction("Confirmation", "Account"));
}
this.ModelState.AddModelError("", "Cannot locate user with your email address");
return(this.View());
}
public ActionResult Login(LoginViewModel login)
{
ConfirmationModel prevScreen = new ConfirmationModel();
prevScreen.PrevScreen = "login";
if (!ModelState.IsValid)
{
return(View("Login", login));
}
return(View("Confirmation", prevScreen));
}
public ActionResult Register(RegistrationViewModel register)
{
ConfirmationModel prevScreen = new ConfirmationModel();
prevScreen.PrevScreen = "register";
if (!ModelState.IsValid)
{
return(View("Register", register));
}
return(View("Confirmation", prevScreen));
}
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
var model = new ConfirmationModel();
var transactionNumberParam = bindingContext.ValueProvider.GetValue("t_numb");
if (transactionNumberParam != null)
{
model.TransactionNumber = transactionNumberParam.AttemptedValue;
}
return(model);
}
public async Task <ActionResult> ChangeStatus(ConfirmationModel model)
{
var response = await _httpClientService.SendRequest("api/clients/status/update", HttpMethod.Put, model.Id);
if (response.IsSuccessStatusCode)
{
return(NotificationSuccessResult(Resource.RecordEditSuccess, Url.RouteUrl(ClientRoutes.Data)));
}
var errorMessage = await _commonService.CheckForValidationErrors(response, Resource.ApplicationErrorText);
return(NotificationErrorResult(errorMessage, Url.RouteUrl(ClientRoutes.Data)));
}
public ActionResult ConfirmRoute(ConfirmationModel confirmModel)
{
if (ModelState.IsValid)
{
var token = GetUserToken();
if (string.IsNullOrEmpty(token))
{
return(Json(new { status = "UnAuthorized" }, JsonRequestBehavior.AllowGet));
}
var res = _routeManager.ConfirmRoute(confirmModel, token);
return(Json(res, JsonRequestBehavior.AllowGet));
}
return(Json(new { status = "WrongInfo" }, JsonRequestBehavior.AllowGet));
}
public IHttpActionResult ConfirmEmail(ConfirmationModel model)
{
if (model.Email != null && model.ValidationId != null)
{
var result = loginFacade.ConfirmEmail(model.ValidationId, model.Email);
if (result)
{
return(Ok());
}
else
{
return(InternalServerError());
}
}
return(NotFound());
}
public async Task <IHttpActionResult> Confirm(ConfirmationModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await userManager.ConfirmEmailAsync(model.UserId, model.ConfirmationToken);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public async Task <ActionResult> Deactivate(ConfirmationModel model)
{
var response = await _httpClientService
.SendRequest($"api/clients/logindata/deactivate", HttpMethod.Put, model.Id);
if (response.IsSuccessStatusCode && model.AdditionalData != null)
{
var userId = (string[])model.AdditionalData;
return(NotificationSuccessResult(Resource.RecordEditSuccess, Url.RouteUrl(ClientLoginDataRoutes.Data, new { userId = userId[0] })));
}
var errorMessage = await _commonService.CheckForValidationErrors(response, Resource.ApplicationErrorText);
return(NotificationErrorResult(errorMessage));
}
public async Task <IActionResult> ConfirmEmail([FromBody] ConfirmationModel model)
{
Log.Info().Message($"Confirming email for user {model.UserId} - {model.Code}").Write();
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
Log.Error().Message($"Could not find user {model.UserId}").Write();
return(this.BadRequest());
}
var result = await userManager.ConfirmEmailAsync(user, model.Code);
return(this.CheckResult(result));
}
/// <summary>
/// Returns confirmation modal dialog to confirm selected operation. Ie. when deleting record etc.
/// </summary>
/// <param name="Id">Record identifier</param>
/// <param name="routeName">Route name to invoke</param>
/// <param name="updateTargetId">HTML element id to refresh</param>
/// <param name="additionalData">Additional data</param>
/// <returns>ActionResult</returns>
public ActionResult Confirmation(string Id, string routeName, string updateTargetId = null, object additionalData = null)
{
if (string.IsNullOrEmpty(routeName))
{
throw new ArgumentNullException(nameof(routeName));
}
var model = new ConfirmationModel
{
RouteName = routeName,
Id = Id,
AdditionalData = additionalData,
UpdateTargetId = updateTargetId
};
return(PartialView("_Confirmation", model: model));
}
public RouteResponseModel ConfirmRoute(ConfirmationModel confirmModel, string token)
{
var list = new List <RouteRequestModel>();
var client = new RestClient(ApiUrl);
var request = new RestRequest("ConfirmRoute", Method.POST);
request.AddHeader("Authorization", "Bearer " + token);
request.AddParameter("RouteIdsCommaSeprated", confirmModel.Ids);
request.AddParameter("ConfirmedText", confirmModel.ConfirmedText);
IRestResponse response = client.Execute(request);
JavaScriptSerializer js = new JavaScriptSerializer();
RouteResponseModel routeResponseModel = new RouteResponseModel();
if (!string.IsNullOrWhiteSpace(response.Content))
{
routeResponseModel = js.Deserialize <RouteResponseModel>(response.Content);
}
return(routeResponseModel);
}
public IHttpActionResult NotConfirmRoute(ConfirmationModel model)
{
ResponseModel responseModel;
try
{
if (!ModelState.IsValid)
{
return(Json(_responseProvider.GenerateBadRequestResponse(ModelState)));
}
foreach (var routeId in model.RouteIds)
{
_routemanager.DeleteRoute(int.Parse(User.Identity.GetUserId()), routeId);
}
return(Json(_responseProvider.GenerateOKResponse()));
}
catch (Exception e)
{
_logmanager.Log(Tag, "ConfirmRoute", e.Message);
}
return(Json(_responseProvider.GenerateUnknownErrorResponse()));
}
public IHttpActionResult ConfirmRoute(ConfirmationModel model)
{
ResponseModel responseModel;
try
{
if (!ModelState.IsValid)
{
return(Json(_responseProvider.GenerateBadRequestResponse(ModelState)));
}
var res = _routemanager.ConfirmRoute(model, int.Parse(User.Identity.GetUserId()));
return(Json(_responseProvider.GenerateResponse(new List <string> {
res
}, "AcceptSuggestedRoute")));
//responseModel = new ResponseModel() { Status = HttpStatusCode.OK.ToString(), StatusCode = HttpStatusCode.OK, Count = 0, Type = ResponseTypes.ConfirmMessage.ToString() };
}
catch (Exception e)
{
_logmanager.Log(Tag, "ConfirmRoute", e.Message);
}
return(Json(_responseProvider.GenerateUnknownErrorResponse()));
}
public async Task <ConfirmationModel> ForgotPassword(ForgotPasswordModel forgotPasswordViewModel)
{
ConfirmationModel confirmationModel;
var user = await _userManager.FindByEmailAsync(forgotPasswordViewModel.Email);
if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
{
confirmationModel = new ConfirmationModel {
Error = true
};
return(confirmationModel);
}
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
confirmationModel = new ConfirmationModel
{
Code = code,
UserId = user.Id
};
return(confirmationModel);
}
public async Task <IActionResult> Confirm()
{
var model = new ConfirmationModel();
return(await Task.FromResult(View(model)));
}
public UpcomingHistory GetUpcomingAndHistoryData(string mail)
{
try
{
UpcomingHistory upcomingHistory = new UpcomingHistory();
HotelBookingDBEntities BookingDB = new HotelBookingDBEntities();
SearchDBEntities searchDB = new SearchDBEntities();
hotelsDBEntities hotelsDB = new hotelsDBEntities();
var BookingData = BookingDB.HotelsBookings.Where(a => a.Booking_Email == mail).ToList();
foreach (var item in BookingData)
{
ConfirmationModel BookingModel = new ConfirmationModel();
var SearchData = searchDB.SearchCriterias.FirstOrDefault(a => a.sID == item.SessionId);
if (SearchData.dateFrom >= DateTime.Now)
{
var hotelData = hotelsDB.hotels.FirstOrDefault(a => a.hotelID == item.Hotel_ID);
var hotelsImage = hotelsDB.HotelsImages.Where(a => a.HotelID == item.Hotel_ID).ToList();
BookingModel.hotel.CheckIn = SearchData.dateFrom.Value.ToString("dd-MM-yyyy");
BookingModel.hotel.CheckOut = SearchData.dateTo.Value.ToString("dd-MM-yyyy");
BookingModel.hotel.City = hotelData.cityName;
BookingModel.hotel.Country = hotelData.countryName;
BookingModel.hotel.hotelCode = item.Hotel_ID;
BookingModel.hotel.hotelName = hotelData.hotelName;
BookingModel.hotel.hotelStars = int.Parse(hotelData.rating) > 0 ? int.Parse(hotelData.rating) - 558 : 0;
BookingModel.hotel.hotelThumb = hotelsImage[0].Thum;
BookingModel.hotel.Location = hotelData.location;
BookingModel.hotel.Paxes = item.Pax_Qty.Value;
BookingModel.hotel.Rooms = item.Rooms_Qty.Value;
BookingModel.hotel.sellCurrency = item.Sell_Currency;
BookingModel.hotel.TotalSellPrice = item.Sell_Price.Value;
BookingModel.bookingNum = item.Booking_No;
BookingModel.mail = item.Booking_Email;
BookingModel.status = item.Booking_Status;
upcomingHistory.Upcoming.Add(BookingModel);
}
else
{
var hotelData = hotelsDB.hotels.FirstOrDefault(a => a.hotelID == item.Hotel_ID);
var hotelsImage = hotelsDB.HotelsImages.Where(a => a.HotelID == item.Hotel_ID).ToList();
BookingModel.hotel.CheckIn = SearchData.dateFrom.Value.ToString("dd-MM-yyyy");
BookingModel.hotel.CheckOut = SearchData.dateTo.Value.ToString("dd-MM-yyyy");
BookingModel.hotel.City = hotelData.cityName;
BookingModel.hotel.Country = hotelData.countryName;
BookingModel.hotel.hotelCode = item.Hotel_ID;
BookingModel.hotel.hotelName = hotelData.hotelName;
BookingModel.hotel.hotelStars = int.Parse(hotelData.rating) > 0 ? int.Parse(hotelData.rating) - 558 : 0;
BookingModel.hotel.hotelThumb = hotelsImage[0].Thum;
BookingModel.hotel.Location = hotelData.location;
BookingModel.hotel.Paxes = item.Pax_Qty.Value;
BookingModel.hotel.Rooms = item.Rooms_Qty.Value;
BookingModel.hotel.sellCurrency = item.Sell_Currency;
BookingModel.hotel.TotalSellPrice = item.Sell_Price.Value;
BookingModel.bookingNum = item.Booking_No;
BookingModel.mail = item.Booking_Email;
BookingModel.status = item.Booking_Status;
upcomingHistory.Histories.Add(BookingModel);
}
}
return(upcomingHistory);
}
catch (Exception ex)
{
LoggingHelper.WriteToFile("UpcomingAndHistoryController/ERRor/", "UpcomingAndHistory" + "INController" + mail, "InComingData", ex.InnerException?.Message + ex.Message + ex.StackTrace);
return(null);
}
}
public ConfirmationModel GetConfirmationData(string sid, string BN)
{
try
{
ConfirmationModel confirmationModel = new ConfirmationModel();
HotelBookingDBEntities BookingDB = new HotelBookingDBEntities();
SearchDBEntities searchDB = new SearchDBEntities();
hotelsDBEntities hotelsDB = new hotelsDBEntities();
HotelBedEntity HBDB = new HotelBedEntity();
List <SearchRoomResult> searchRoomResults = new List <SearchRoomResult>();
List <SearchRoomResult> SelectedRooms = new List <SearchRoomResult>();
var BookingData = BookingDB.HotelsBookings.FirstOrDefault(a => a.SessionId == sid && a.Booking_No == BN);
var Paxes = BookingDB.HotelBookingPaxs.Where(x => x.Booking_No == BN && x.SID == sid && x.PaxNo == 1);
var SearchData = searchDB.SearchCriterias.FirstOrDefault(a => a.sID == sid);
var RoomData = searchDB.SearchRoomDatas.Where(a => a.sID == sid).ToList();
var Rooms = Paxes.Select(x => x.RoomRef.ToString()).ToList();
foreach (var item in Rooms)
{
var roomsearch = searchDB.SearchRoomResults.FirstOrDefault(r => r.sID == sid && r.HotelCode == BookingData.Hotel_ID && r.RoomCode == item);
SelectedRooms.Add(roomsearch);
}
if (BookingData.Provider_ID == "4")
{
var hotelData = hotelsDB.hotels.FirstOrDefault(a => a.hotelID == BookingData.Hotel_ID);
var hotelDesc = hotelsDB.HotelsDescriptions.FirstOrDefault(a => a.hotelID == BookingData.Hotel_ID);
confirmationModel.hotel.HotelDescription = hotelDesc.Description1;
var hotelsImage = hotelsDB.HotelsImages.Where(a => a.HotelID == BookingData.Hotel_ID).ToList();
confirmationModel.hotel.City = hotelData.cityName;
confirmationModel.hotel.Country = hotelData.countryName;
confirmationModel.hotel.hotelCode = BookingData.Hotel_ID;
confirmationModel.hotel.hotelName = hotelData.hotelName;
confirmationModel.hotel.Address = hotelData.address;
confirmationModel.hotel.hotelStars = int.Parse(hotelData.rating);
if (hotelsImage.Count > 0)
{
confirmationModel.hotel.hotelThumb = hotelsImage[0].Thum;
}
confirmationModel.hotel.Location = hotelData.location;
}
else if (BookingData.Provider_ID == "5")
{
using (TBOContext tBOContext = new TBOContext())
{
var hotelData = tBOContext.HotelDetails.FirstOrDefault(a => a.HotelCode == BookingData.Hotel_ID);
var hotelDesc = hotelData.Description;
var hotelsImage = tBOContext.HotelImages.Where(a => a.HotelCode == BookingData.Hotel_ID).ToList();
confirmationModel.hotel.City = hotelData.CityName;
confirmationModel.hotel.Country = hotelData.CountryName;
confirmationModel.hotel.hotelCode = BookingData.Hotel_ID;
confirmationModel.hotel.hotelName = hotelData.HotelName;
confirmationModel.hotel.Address = hotelData.Address;
//confirmationModel.hotel.hotelStars = int.Parse(hotelData.rating);
if (hotelsImage.Count > 0)
{
confirmationModel.hotel.hotelThumb = hotelsImage[0].URL;
}
confirmationModel.hotel.Location = hotelData.HotelLocation;
}
}
confirmationModel.hotel.CheckIn = SearchData.dateFrom.Value.ToString();
confirmationModel.BookingTime = BookingData.Booking_Time.Value;
confirmationModel.hotel.CheckOut = SearchData.dateTo.Value.ToString();
confirmationModel.hotel.Paxes = BookingData.Pax_Qty.Value;
confirmationModel.hotel.Rooms = BookingData.Rooms_Qty.Value;
var PConfirm = BookingDB.BookingConfirmationDatas.FirstOrDefault(a => a.SessionID == sid && a.BookingNum == BN);
if (PConfirm != null)
{
confirmationModel.ProviderConfirmation = PConfirm.Reference;
}
confirmationModel.hotel.sellCurrency = BookingData.Sell_Currency;
confirmationModel.hotel.TotalSellPrice = BookingData.Sell_Price.Value;
confirmationModel.bookingNum = BookingData.Booking_No;
confirmationModel.mail = BookingData.Booking_Email;
confirmationModel.status = BookingData.Booking_Status;
CurrencyRepo repo = new CurrencyRepo();
double ExcahngeRate = repo.GetEveryDayCurrenciesConversion(SearchData.currency, BookingData.Sell_Currency, sid, DateTime.Now).Result.Customer_Sell_Rate;
foreach (var item in Paxes)
{
ConfirmedTraveller traveller = new ConfirmedTraveller();
traveller.FirstName = item.First_name;
traveller.LastName = item.Last_Name;
traveller.Title = item.Salutations;
var roomResult = SelectedRooms.FirstOrDefault(x => x.RoomCode == item.RoomRef.ToString());
searchRoomResults.Add(roomResult);
var specRoom1 = SelectedRooms.FirstOrDefault(s => s.RoomCode == item.RoomRef.ToString());
if (specRoom1.Childern != 0)
{
var specRoom = SelectedRooms.FirstOrDefault(s => s.RoomCode == item.RoomRef.ToString());
var childern = RoomData.Where(a => a.adultNo == specRoom.Adults && a.childernNo == specRoom.Childern).ToList();
if (childern.Count == 1)
{
var childages = childern[0].childAge.Split('-');
traveller.ChildAge.AddRange(childages.ToList());
}
else
{
var child = RoomData.FirstOrDefault(a => a.adultNo == specRoom.Adults && a.childernNo == specRoom.Childern && a.roomNo == item.RoomRef);
var childages = child.childAge.Split('-');
traveller.ChildAge.AddRange(childages.ToList());
}
}
confirmationModel.travellers.Add(traveller);
}
foreach (var item in searchRoomResults)
{
ConfirmedRoom confirmedRoom = new ConfirmedRoom();
if (BookingData.Provider_ID == "5")
{
var roomNo = int.Parse(item.RoomCode);
confirmedRoom.Adult = RoomData.FirstOrDefault(ad => ad.roomNo == roomNo).adultNo ?? default(int);
confirmedRoom.Child = RoomData.FirstOrDefault(ad => ad.roomNo == roomNo).childernNo ?? default(int);
}
else
{
confirmedRoom.Adult = item.Adults.Value;
confirmedRoom.Child = item.Childern.Value;
}
//var RoomsImage = hotelsImage.Where(a => a.Category.ToLower() == "hotel rooms").ToList();
//***************
//if (RoomsImage.Count > 0)
//{
//confirmedRoom.Image = RoomsImage[0].URL;
//}
confirmedRoom.IsRefundable = item.IsRefundable.Value;
confirmedRoom.Paxs = item.PaxSQty.Value;
confirmedRoom.RoomCode = item.RoomCode;
confirmedRoom.RoomMeal = item.meal;
confirmedRoom.RoomType = item.RoomName;
confirmedRoom.RateType = item.rateType;
List <CancelPolicy> cancelPolicies = new List <CancelPolicy>();
using (HotelBookingDBEntities db = new HotelBookingDBEntities())
{
cancelPolicies = db.CancelPolicies.Where(a => a.Sid == sid && a.HotelCode == BookingData.Hotel_ID && a.RoomCode.ToString() == item.RoomCode && a.ProviderID == BookingData.Provider_ID).ToList();
}
if (cancelPolicies.Count > 0)
{
foreach (var p in cancelPolicies)
{
CancellationRule cancellation = new CancellationRule();
cancellation.FromDate = p.FromDate.ToString();
if (BookingData.Sell_Currency == p.Currency)
{
cancellation.Price = (double)p.SellPrice.Value;
}
else
{
cancellation.Price = (double)p.SellPrice.Value * ExcahngeRate;
}
cancellation.CanellationRuleText = cancellation.Price + " " + BookingData.Sell_Currency + " From " + p.FromDate.Value.ToString("MMMM dd, yyyy");
confirmedRoom.cancellations.Add(cancellation);
}
}
confirmationModel.rooms.Add(confirmedRoom);
}
var ConfData = HBDB.BookingConfirmations.FirstOrDefault(a => a.BookingNum == BN);
if (ConfData != null)
{
confirmationModel.PayableNote = "Payable through " + ConfData.supplier + ", acting as agent for the service operating company, details of which can be provided upon request. VAT: " + ConfData.Remark + " Reference:" + ConfData.Reference;
}
return(confirmationModel);
}catch (Exception ex)
{
LoggingHelper.WriteToFile("ConfirmationController/ERROR/", "ConfirmationDAL" + "INDAL" + sid, "ConfirmData", "Sid is " + sid + " and Booking is" + BN + ex.InnerException?.Message + ex.Message + ex.StackTrace);
return(null);
}
}
public IActionResult Confirmation(ConfirmationModel confirmationModel)
{
return(View(confirmationModel));
}
public ConfirmationDialog()
{
InitializeComponent();
ModelServiceLocator serviceLocator = this.FindResource<ModelServiceLocator>("serviceLocator");
this.model = serviceLocator.ConfirmationModel;
}
