private async Task SaveAsync()
{
if (ShippingAddressViewModel.ValidateForm())
{
string errorMessage = string.Empty;
try
{
await ShippingAddressViewModel.ProcessFormAsync();
_navigationService.GoBack();
}
catch (ModelValidationException mvex)
{
DisplayValidationErrors(mvex.ValidationResult);
}
catch (Exception ex)
{
errorMessage = string.Format(CultureInfo.CurrentCulture, _resourceLoader.GetString("GeneralServiceErrorMessage"), Environment.NewLine, ex.Message);
}
if (!string.IsNullOrWhiteSpace(errorMessage))
{
await _alertMessageService.ShowAsync(errorMessage, _resourceLoader.GetString("ErrorServiceUnreachable"));
}
}
}
private async void GoNext()
{
IsShippingAddressInvalid = ShippingAddressViewModel.ValidateForm() == false;
IsBillingAddressInvalid = !UseSameAddressAsShipping && BillingAddressViewModel.ValidateForm() == false;
IsPaymentMethodInvalid = PaymentMethodViewModel.ValidateForm() == false;
if (IsShippingAddressInvalid || IsBillingAddressInvalid || IsPaymentMethodInvalid)
{
return;
}
string errorMessage = string.Empty;
try
{
await _accountService.VerifyUserAuthenticationAsync();
await ProcessFormAsync();
}
catch (Exception ex)
{
errorMessage = string.Format(CultureInfo.CurrentCulture, _resourceLoader.GetString("GeneralServiceErrorMessage"), Environment.NewLine, ex.Message);
}
if (!string.IsNullOrWhiteSpace(errorMessage))
{
await _alertMessageService.ShowAsync(errorMessage, _resourceLoader.GetString("ErrorServiceUnreachable"));
}
}
public override void OnNavigatedTo(NavigatedToEventArgs e, Dictionary <string, object> viewModelState)
{
if (viewModelState == null)
{
return;
}
// Try to populate address and payment method controls with default data if available
ShippingAddressViewModel.SetLoadDefault(true);
BillingAddressViewModel.SetLoadDefault(true);
PaymentMethodViewModel.SetLoadDefault(true);
// This ViewModel is an example of composition. The CheckoutHubPageViewModel manages
// three child view models (Shipping Address, Billing Address, and Payment Method).
// Since the FrameNavigationService calls this OnNavigatedTo method, passing in
// a viewModelState dictionary, it is the responsibility of the parent view model
// to manage separate dictionaries for each of its children. If the parent view model
// were to pass its viewModelState dictionary to each of its children, it would be very
// easy for one child view model to write over a sibling view model's state.
if (e.NavigationMode == NavigationMode.New)
{
viewModelState["ShippingViewModel"] = new Dictionary <string, object>();
viewModelState["BillingViewModel"] = new Dictionary <string, object>();
viewModelState["PaymentMethodViewModel"] = new Dictionary <string, object>();
}
ShippingAddressViewModel.OnNavigatedTo(e, viewModelState["ShippingViewModel"] as Dictionary <string, object>);
BillingAddressViewModel.OnNavigatedTo(e, viewModelState["BillingViewModel"] as Dictionary <string, object>);
PaymentMethodViewModel.OnNavigatedTo(e, viewModelState["PaymentMethodViewModel"] as Dictionary <string, object>);
base.OnNavigatedTo(e, viewModelState);
}
public override void OnNavigatingFrom(NavigatingFromEventArgs e, Dictionary <string, object> viewModelState, bool suspending)
{
if (viewModelState == null || viewModelState.Count == 0)
{
return;
}
ShippingAddressViewModel.OnNavigatingFrom(e, viewModelState["ShippingViewModel"] as Dictionary <string, object>, suspending);
BillingAddressViewModel.OnNavigatingFrom(e, viewModelState["BillingViewModel"] as Dictionary <string, object>, suspending);
PaymentMethodViewModel.OnNavigatingFrom(e, viewModelState["PaymentMethodViewModel"] as Dictionary <string, object>, suspending);
base.OnNavigatingFrom(e, viewModelState, suspending);
}
public async Task <IActionResult> MyShippingAddress(ShippingAddressViewModel model)
{
var user = await _userManager.GetUserAsync(User);
user.ShippingPropertyName = model.PropertyName;
user.ShippingStreetAdress = model.StreetAdress;
user.ShippingTownCity = model.TownCity;
user.ShippingZipPostcode = model.Postcode;
user.ShippingCountry = model.Country;
await _userManager.UpdateAsync(user);
return(View(model));
}
public override async void OnNavigatedTo(object navigationParameter, Windows.UI.Xaml.Navigation.NavigationMode navigationMode, Dictionary <string, object> viewModelState)
{
if (await _accountService.VerifyUserAuthenticationAsync() == null)
{
return;
}
var addressId = navigationParameter as string;
HeaderLabel = string.IsNullOrWhiteSpace(addressId)
? _resourceLoader.GetString("AddShippingAddressTitle")
: _resourceLoader.GetString("EditShippingAddressTitle");
ShippingAddressViewModel.OnNavigatedTo(navigationParameter, navigationMode, viewModelState);
}
public ActionResult AddAddreessForUser(ShippingAddressViewModel objShippingAddressViewModel)
{
try
{
objShippingAddressViewModel.retailer_mobile = LoggedInUser.MobileNumber;
var addAddress = ObjIUserService.AddAddreessForUser(objShippingAddressViewModel);
if (addAddress)
{
TempData["AddressSuccess"] = Resource.GrowOnline_Message_AddAddress;
return(Json(addAddress, JsonRequestBehavior.AllowGet));
//return Json("true", JsonRequestBehavior.AllowGet);
}
else
{
TempData["AddressSuccess"] = Resource.GrowOnline_Message_ErrorAddAddress;
return(Json(addAddress, JsonRequestBehavior.AllowGet));
}
}
catch (Exception ex)
{
throw ex;
}
}
public bool AddAddreessForUser(ShippingAddressViewModel objShippingAddressViewModel)
{
Shop_Shipping_address objShop_Shipping_address = new Shop_Shipping_address();
objShop_Shipping_address.reciver_name = objShippingAddressViewModel.reciver_name;
objShop_Shipping_address.retailer_mobile = objShippingAddressViewModel.retailer_mobile;
objShop_Shipping_address.email_id = objShippingAddressViewModel.email_id;
objShop_Shipping_address.StreetLine1 = objShippingAddressViewModel.StreetLine1;
objShop_Shipping_address.StreetLine2 = objShippingAddressViewModel.StreetLine2;
objShop_Shipping_address.HouseNumber = objShippingAddressViewModel.HouseNumber;
objShop_Shipping_address.StateCode = objShippingAddressViewModel.StateId;
objShop_Shipping_address.DistrictCode = objShippingAddressViewModel.DistrictId;
objShop_Shipping_address.TalukaCode = objShippingAddressViewModel.TalukaId;
objShop_Shipping_address.VillageCode = objShippingAddressViewModel.VillageId;
objShop_Shipping_address.city = objShippingAddressViewModel.city;
objShop_Shipping_address.pincode = objShippingAddressViewModel.pincode;
objShop_Shipping_address.retailer_id = "12345";
objShop_Shipping_address.ship_mobile = objShippingAddressViewModel.ship_mobile;
objShop_Shipping_address.landline_number = objShippingAddressViewModel.landline_number;
objShop_Shipping_address.tr_date = DateTime.Now;
var adddress = objIUser.AddAddreessForUser(objShop_Shipping_address);
return(adddress);
}
private async Task <OrderViewModel> GetOrderViewModel(Guid orderId)
{
OrderViewModel vm = null;
try
{
var order = await _context.Orders.SingleOrDefaultAsync(m => m.ID == orderId);
var olines = await _context.OrderLines.Where(ol => ol.OrderID.Equals(order.ID)).ToListAsync();
List <OrderLineViewModel> lineViewModels = new List <OrderLineViewModel>();
foreach (var item in olines)
{
Product product = null;
product = await _context.Products.SingleAsync(p => p.ProductID == item.ProductID);
var mainImage = await _context.ProductImages.SingleAsync(i => i.IsMainImage && i.ProductID.Equals(item.ProductID));
var unit = await _context.Units.SingleAsync(u => u.UnitID == item.UnitID);
OrderLineViewModel lineViewModel = new OrderLineViewModel {
ID = item.OrderLineID,
Image = mainImage.ImageUrl,
OrderPrice = item.SellBasePrice,
OrderQuantity = item.Quantity,
ProductName = product.Name,
OrderUnit = unit.Name,
OrderLineTotal =
item.Quantity * item.SellBasePrice,
Position = item.Position,
ProductNumber = product.ProductNumber
};
lineViewModels.Add(lineViewModel);
}
var shippingPrice = await _context.ShippingPrices.SingleAsync(sp => sp.ID == order.ShippingPriceId);
var shippingPeriod = await _context.ShpippingPeriods.SingleAsync(p => p.ShippingPeriodID == order.ShippingPeriodId);
var paymend = await _context.Paymends.SingleAsync(p => p.ID == order.PaymentID);
var customer = await _context.Customers.SingleAsync(c => c.CustomerID.Equals(order.CustomerID));
var user = await _context.Users.SingleAsync(u => u.Id.Equals(customer.UserId));
var shippingAddress = await _context.ShippingAddresses.FirstOrDefaultAsync(s => s.ID == order.ShippingAddressId);
var invoiceaddress = await _context.ShippingAddresses.FirstOrDefaultAsync(c => c.CustomerID == order.CustomerID && c.IsInvoiceAddress);
ShippingAddressViewModel shipToAddress = null;
if (shippingAddress != null)
{
shipToAddress = addressHelper.GetViewModel(shippingAddress);
}
ShippingAddressViewModel invoiceVm = null;
if (invoiceaddress == null)
{
invoiceVm = addressHelper.GetViewModel(customer);
}
else
{
invoiceVm = addressHelper.GetViewModel(invoiceaddress);
}
vm = new OrderViewModel {
ID = order.ID,
EMail = user.UserName,
ExceptLawConditions = order.ExceptLawConditions,
IsClosed = order.IsClosed,
IsPayed = order.IsPayed,
IsSend = order.IsSend,
Number = order.Number,
OrderDate = order.OrderDate,
FreeText = order.FreeText,
Payment = paymend.Name,
Shippingdate = order.Shippingdate,
ShippingPriceAtOrder = order.ShippingPrice,
ShippingPriceName = shippingPrice.Name,
ShippToAddress = shipToAddress,
InvoiceAddress = invoiceVm,
ShippingPeriodString = shippingPeriod.Decription,
Total = order.Total,
CustomerFirstName = customer.FirstName,
CutomerLastName = customer.Name,
OderLines = lineViewModels
};
}
catch (Exception e)
{
_logger.LogError(e, "Admin.OrdersController.GetViewModel -> error on sql transaction", null);
}
return(vm);
}
public override void OnNavigatedFrom(Dictionary <string, object> viewModelState, bool suspending)
{
ShippingAddressViewModel.OnNavigatedFrom(viewModelState, suspending);
}
public override void OnNavigatingFrom(NavigatingFromEventArgs e, Dictionary <string, object> viewModelState, bool suspending)
{
ShippingAddressViewModel.OnNavigatingFrom(e, viewModelState, suspending);
}
private async Task <AdminCustomerViewModel> GetCustomerViewModel(Guid id)
{
AdminCustomerViewModel result = new AdminCustomerViewModel();
var customer = await _context.Customers.SingleAsync(c => c.CustomerID == id);
var user = await _context.Users.SingleAsync(u => u.Id == customer.UserId);
var countries = await _context.Countries.ToListAsync();
List <ShippingAddress> shipToAddresses = null;
var openorders = await _context.Orders.Where(o => o.CustomerID == id && !o.IsClosed).ToListAsync();
var closedorders = await _context.Orders.Where(o => o.CustomerID == id && o.IsClosed).ToListAsync();
var vmOpenOrders = new List <OrderViewModel>();
var vmClosedOrders = new List <OrderViewModel>();
foreach (var item in openorders)
{
var op = new OrderViewModel {
ID = item.ID, Number = item.Number, OrderDate = item.OrderDate
};
vmOpenOrders.Add(op);
}
foreach (var item in closedorders)
{
var cl = new OrderViewModel {
ID = item.ID, Number = item.Number, OrderDate = item.OrderDate
};
vmClosedOrders.Add(cl);
}
try
{
shipToAddresses = await _context.ShippingAddresses.Where(sh => sh.CustomerID == customer.CustomerID).ToListAsync();
}
catch (Exception e)
{
logger.LogError(e, "Fehler beim abrufen einer Lieferadresse.");
shipToAddresses = null;
}
result.CustomerID = customer.CustomerID;
result.CustomerNo = customer.CustomerNo;
result.FirstName = customer.FirstName;
result.Name = customer.Name;
result.PostCode = customer.PostCode;
result.UserEmail = user.Email;
result.UserId = user.Id;
result.IsEmailConfirmed = user.EmailConfirmed;
result.City = customer.City;
result.AdditionalAddress = customer.AdditionalAddress;
result.Address = customer.Address;
result.AllowedPayByBill = customer.AllowedPayByBill;
result.Addresses = new List <ShippingAddressViewModel>();
result.CountryId = customer.CountryId;
result.CountryName = countries.Single(c => c.ID == customer.CountryId).Name;
result.OpenOrders = vmOpenOrders;
result.ClosedOrders = vmClosedOrders;
if (shipToAddresses != null)
{
foreach (var item in shipToAddresses)
{
var shipTo = new ShippingAddressViewModel
{
ID = item.ID,
Address = item.Address,
AdditionalAddress = item.AdditionalAddress,
City = item.City,
CountryID = item.CountryID,
CountryName = countries.Single(c => c.ID == item.CountryID).Name,
CustomerID = item.CustomerID,
FirstName = item.FirstName,
IsMainAddress = item.IsMainAddress,
LastName = item.LastName,
PostCode = item.PostCode,
IsInvoiceAddress = item.IsInvoiceAddress
};
result.Addresses.Add(shipTo);
}
}
return(result);
}
private async Task ProcessFormAsync()
{
if (UseSameAddressAsShipping)
{
BillingAddressViewModel.Address = new Address
{
Id = Guid.NewGuid().ToString(),
AddressType = AddressType.Billing,
FirstName = ShippingAddressViewModel.Address.FirstName,
MiddleInitial = ShippingAddressViewModel.Address.MiddleInitial,
LastName = ShippingAddressViewModel.Address.LastName,
StreetAddress = ShippingAddressViewModel.Address.StreetAddress,
OptionalAddress = ShippingAddressViewModel.Address.OptionalAddress,
City = ShippingAddressViewModel.Address.City,
State = ShippingAddressViewModel.Address.State,
ZipCode = ShippingAddressViewModel.Address.ZipCode,
Phone = ShippingAddressViewModel.Address.Phone
};
}
try
{
await ShippingAddressViewModel.ProcessFormAsync();
await BillingAddressViewModel.ProcessFormAsync();
await PaymentMethodViewModel.ProcessFormAsync();
}
catch (ModelValidationException)
{
// Handle validation exceptions when the order is created.
}
var user = _accountService.SignedInUser;
var shoppingCart = await _shoppingCartRepository.GetShoppingCartAsync();
try
{
// Create an order with the values entered in the form
await _orderRepository.CreateBasicOrderAsync(user.UserName, shoppingCart, ShippingAddressViewModel.Address, BillingAddressViewModel.Address, PaymentMethodViewModel.PaymentMethod);
_navigationService.Navigate("CheckoutSummary", null);
}
catch (ModelValidationException mvex)
{
DisplayOrderErrorMessages(mvex.ValidationResult);
if (_shippingAddressViewModel.Address.Errors.Errors.Count > 0)
{
IsShippingAddressInvalid = true;
}
if (_billingAddressViewModel.Address.Errors.Errors.Count > 0 && !UseSameAddressAsShipping)
{
IsBillingAddressInvalid = true;
}
if (_paymentMethodViewModel.PaymentMethod.Errors.Errors.Count > 0)
{
IsPaymentMethodInvalid = true;
}
}
}
// GET: Orders/Create
public async Task <IActionResult> Create(Guid?id)
{
cartHelper.CheckAndRemove();
OrderCreateViewModel vm = new OrderCreateViewModel();
List <ShippingAddress> addresses = new List <ShippingAddress>();
var identity = User.Identity;
var currentUser = _userManager.Users.Single(u => u.UserName == identity.Name);
var userId = currentUser.Id;
var customer = await _context.Customers.Where(c => c.UserId == userId).SingleAsync();
ShippingPrice shippingPriceDefault = null;
decimal shipDefaultPrice = 0.0M;
int countryDefault = 1; //Country 1 Deutschland
int ShippingPeriodDefaultID = 1;
if (customer.CustomerID != Guid.Empty)
{
var shipping = await _context.ShippingAddresses.SingleOrDefaultAsync(c => c.CustomerID == customer.CustomerID && c.IsMainAddress);
if (shipping == null)
{
return(RedirectToAction("CustomerIndex", "ShippingAddresses", new { id = customer.CustomerID }));
}
countryDefault = shipping.CountryID;
}
var countries = await _context.Countries.ToListAsync();
var country = countries.Single(c => c.ID == countryDefault);
ViewData["CustomerCountryCode"] = country.Code;
if (id != null)
{
Guid cartId = (Guid)id;
var shoppingCart = await _context.ShoppingCarts.SingleAsync(sc => sc.ID == id);
decimal total = 0.0M;
var lines = _context.ShoppingCartLines.Where(l => l.ShoppingCartID.Equals(shoppingCart.ID));
List <CartLineViewModel> vmcLines = new List <CartLineViewModel>();
foreach (var item in lines)
{
string path = string.Empty;
try
{
path = _context.ProductImages.Where(i => i.ProductID.Equals(item.ProductID) && i.IsMainImage).SingleOrDefault().ImageUrl;
}
catch (Exception)
{
path = "noImage.svg";
}
var product = _context.Products.Where(p => p.ProductID.Equals(item.ProductID)).SingleOrDefault();
if (ShippingPeriodDefaultID < product.ShippingPeriod)
{
ShippingPeriodDefaultID = product.ShippingPeriod;
}
var productShipPrice = await _context.ShippingPrices.SingleAsync(s => s.ShippingPriceTypeId == product.ShippingPriceType && s.CountryId == countryDefault);
if (shipDefaultPrice < productShipPrice.Price)
{
shipDefaultPrice = productShipPrice.Price;
shippingPriceDefault = productShipPrice;
}
decimal baseprice = _context.Products.Where(p => p.ProductID.Equals(item.ProductID)).SingleOrDefault().Price;
decimal pPrice = 0.0M;
if (baseprice != 0.0M)
{
pPrice = baseprice * item.Quantity;
}
if (string.IsNullOrEmpty(path))
{
path = "noImage.svg";
}
var unitHelper = new UnitHelper(_context, factory);
string unit = unitHelper.GetUnitName(product.BasesUnitID);
string sekunit = unitHelper.GetUnitName(product.SecondBaseUnit);
CartLineViewModel cvml = new CartLineViewModel()
{
ID = item.ID,
CartID = item.ShoppingCartID,
ImgPath = path,
Position = item.Position,
PosPrice = Math.Round(pPrice, 2),
Quantity = Math.Round(item.Quantity, 2),
ProductID = item.ProductID,
Unit = unit,
ProductName = product.Name,
ProductNo = product.ProductNumber.ToString(),
MinimumPurchaseQuantity = Math.Round(product.MinimumPurchaseQuantity, 2),
AvailableQuantity = Math.Round(product.AvailableQuantity, 2),
ShoppingCartID = shoppingCart.ID,
SellBasePrice = Math.Round(item.SellBasePrice, 2),
SellSekPrice = Math.Round(product.SecondBasePrice, 2),
SekUnit = sekunit,
ShortDescription = product.ShortDescription,
UnitID = product.BasesUnitID
};
vmcLines.Add(cvml);
total = total + pPrice;
}
CartViewModel cvm = new CartViewModel()
{
ID = shoppingCart.ID,
Number = shoppingCart.Number,
OrderId = shoppingCart.OrderId,
Lines = vmcLines,
Total = total,
};
addresses = await _context.ShippingAddresses.Where(sh => sh.CustomerID == customer.CustomerID).ToListAsync();
vm.ShippingAddresseVMs = new List <ShippingAddressViewModel>();
int mainShipID = 0;
foreach (var item in addresses)
{
var shipVm = new ShippingAddressViewModel
{
ID = item.ID,
FirstName = item.FirstName,
LastName = item.LastName,
Address = item.Address,
AdditionalAddress = item.AdditionalAddress,
PostCode = item.PostCode,
City = item.City,
CountryID = item.CountryID,
CustomerID = item.CustomerID,
IsMainAddress = item.IsMainAddress,
CountryName = countries.Single(c => c.ID == item.CountryID).Name
};
if (shipVm.IsMainAddress)
{
mainShipID = shipVm.ID;
}
vm.ShippingAddresseVMs.Add(shipVm);
}
string strOrderNo = await GetActualOrderNo();
vm.Cart = cvm;
vm.Order = new Order();
vm.Order.Number = strOrderNo;
vm.Order.CartID = cvm.ID;
vm.Order.ShippingAddressId = mainShipID;
vm.Order.OrderDate = DateTime.Now;
}
var paymends = await _context.Paymends.ToListAsync();
ShippingPeriod periodDefault = await _context.ShpippingPeriods.SingleAsync(s => s.ShippingPeriodID == ShippingPeriodDefaultID);
vm.Cart.Total = vm.Cart.Total + shipDefaultPrice;
vm.Cart.Total = Math.Round(vm.Cart.Total, 2);
vm.PayPalTotal = Math.Round(vm.Cart.Total, 2).ToString(CultureInfo.CreateSpecificCulture("en-US"));
shipDefaultPrice = Math.Round(shipDefaultPrice);
vm.ShippingPrice = shippingPriceDefault;
vm.ShippingPeriod = periodDefault;
vm.CanBuyWithBill = customer.AllowedPayByBill;
ViewData["Paymends"] = paymends;
return(View(vm));
}
private async Task <WeHaveYourOrderViewModel> GetViewModel(Guid id)
{
var myorder = await _context.Orders.SingleAsync(o => o.ID == id);
var paymend = await _context.Paymends.SingleAsync(p => p.ID == myorder.PaymentID);
var shippingAddress = await _context.ShippingAddresses.SingleAsync(a => a.ID == myorder.ShippingAddressId);
var invioceAddress = await _context.ShippingAddresses.FirstOrDefaultAsync(a => a.CustomerID == myorder.CustomerID && a.IsInvoiceAddress);
var period = await _context.ShpippingPeriods.SingleAsync(p => p.ShippingPeriodID == myorder.ShippingPeriodId);
var shipPrice = await _context.ShippingPrices.SingleAsync(p => p.ID == myorder.ShippingPriceId);
var olines = await _context.OrderLines.Where(ol => ol.OrderID.Equals(myorder.ID)).ToListAsync();
List <WeHaveYourOrderLineViewModel> lineViewModels = new List <WeHaveYourOrderLineViewModel>();
foreach (var item in olines)
{
var prod = await _context.Products.SingleAsync(p => p.ProductID == item.ProductID);
var img = await _context.ProductImages.SingleAsync(p => p.IsMainImage && p.ProductID == item.ProductID);
var unit = await _context.Units.SingleAsync(u => u.UnitID == prod.BasesUnitID);
var line = new WeHaveYourOrderLineViewModel
{
ID = item.OrderLineID,
ImagePath = img.ImageUrl,
Position = item.Position,
Price = Math.Round((item.SellBasePrice * item.Quantity), 2),
ProductName = prod.Name,
ProductNumber = prod.ProductNumber,
Quantity = Math.Round(item.Quantity, 2),
ProductUnit = unit.Name
};
lineViewModels.Add(line);
}
BankAcccount bank = null;
var shipTo = addressHelper.GetViewModel(shippingAddress);
ShippingAddressViewModel invoiceVm = null;
if (invioceAddress == null)
{
var customer = await _context.Customers.SingleAsync(c => c.CustomerID == myorder.CustomerID);
invoiceVm = addressHelper.GetViewModel(customer);
}
else
{
invoiceVm = addressHelper.GetViewModel(invioceAddress);
}
string thankyou = await GetThankyou(paymend);
WeHaveYourOrderViewModel viewModel = new WeHaveYourOrderViewModel
{
OrderID = myorder.ID,
OrderDate = myorder.OrderDate,
OrderNo = myorder.Number,
OrderPaymend = paymend.Name,
OrderShippingAddress = shipTo,
OrderInvoiceAddress = invoiceVm,
OrderShippingPeriod = period.Decription,
Bank = bank,
OrderTotal = Math.Round(myorder.Total, 2),
OrderThankYou = thankyou,
ShipPrice = Math.Round(myorder.ShippingPrice, 2),
ShipPriceName = shipPrice.Name,
OrderLines = lineViewModels,
FreeText = myorder.FreeText
};
return(viewModel);
}
