private void AddressList_Refreshing(object sender, EventArgs e)
{
CustomerAddressViewModel model = new CustomerAddressViewModel();
addressList.BindingContext = model;
addressList.EndRefresh();
}
public void UpdateSiteCustomerAddress(CustomerAddressViewModel model)
{
var item = m_ContentContext.Customer_Addresses.FirstOrDefault(f => f.Id == model.Id);
Mapper.Map(model, item);
m_ContentContext.SaveChanges();
}
public ActionResult SuspendService(Customer customer)
{
try
{
var customerFromDb = GetCustomer();
var pickup = GetPickups(customerFromDb);
if (customerFromDb == null)
{
return(HttpNotFound());
}
var viewModel = new CustomerAddressViewModel
{
Customer = customerFromDb,
Pickup = pickup[0]
};
viewModel.Customer.SuspendStartDate = customer.SuspendStartDate;
viewModel.Customer.SuspendEndDate = customer.SuspendEndDate;
context.SaveChanges();
return(View("Index", viewModel));
}
catch
{
return(View());
}
}
public void InsertSiteCustomerAddress(CustomerAddressViewModel model)
{
var item = Mapper.Map <Customer_Addresses>(model);
m_ContentContext.Customer_Addresses.Add(item);
m_ContentContext.SaveChanges();
}
public ActionResult AddressList(int CustomerID)
{
ViewData["CustomerId"] = CustomerID;
/* return View((_context.CustomerAddress.Where(x => x.CustomerId == CustomerID)).ToList());*/
List <CustomerAddressViewModel> customerAddressList = new List <CustomerAddressViewModel>();
IEnumerable <CustomerAddress> addressList;
/*Here ToList is used to avoid the error : openDataReader associated with this command */
addressList = _context.CustomerAddress.Where(x => x.CustomerId == CustomerID).ToList();
foreach (CustomerAddress customer in addressList)
{
CustomerAddressViewModel model = new CustomerAddressViewModel();
model.AddressId = customer.AddressId;
model.Street = customer.Street;
model.City = customer.City;
var stateInfo = from d in _context.StateMaster.Where(d => d.StateId == customer.StateorProvince).ToList()
select new { d.StateName };
foreach (var info in stateInfo)
{
model.StateorProvince = info.StateName;
// model.Country = info.CountryName;
}
var countryInfo = from b in _context.CountryMaster.Where(b => b.CountryId == customer.Country).ToList()
select new { b.CountryName };
foreach (var info in countryInfo)
{
// model.StateorProvince = info.CountryName;
model.Country = info.CountryName;
}
customerAddressList.Add(model);
}
ViewBag.CustomerAddress = customerAddressList;
return(View());
}
public ActionResult UpdatePickup(CustomerAddressViewModel Model)
{
try
{
var customer = GetCustomer();
if (customer == null)
{
return(HttpNotFound());
}
var pickup = context.Pickups.FirstOrDefault(p => p.CustomerId == customer.Id);
pickup.PickupDay = Model.Pickup.PickupDay;
pickup.PickupDate = GetDateFromDay(pickup.PickupDay);
if (pickup.SecondPickupDate == null && Model.Pickup.SecondPickupDate != null)
{
pickup.SecondPickupDate = Model.Pickup.SecondPickupDate;
pickup.SecondPickupDay = pickup.SecondPickupDate.Value.DayOfWeek;
Pickup extraPickup = new Pickup();
extraPickup.PickupDate = Model.Pickup.SecondPickupDate;
extraPickup.PickupDay = extraPickup.PickupDate.Value.DayOfWeek;
extraPickup.CustomerId = customer.Id;
extraPickup.Status = "Not-completed";
context.Pickups.Add(extraPickup);
customer.ExtraPickupRequest = true;
}
context.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult AddressSave(CustomerAddressViewModel customerAddressViewModel)
{
if (!ModelState.IsValid)
{
return(View("AddressForm", customerAddressViewModel));
}
Address addressInDB = null;
if (_customer.AddressId != null)
{
addressInDB = _context.Address.SingleOrDefault(a => a.Id == _customer.AddressId);
}
else
{
addressInDB = new Address();
_context.Address.Add(addressInDB);
_context.SaveChanges();
_customer.AddressId = addressInDB.Id;
}
addressInDB.Street = customerAddressViewModel.Address.Street;
addressInDB.Street2 = customerAddressViewModel.Address.Street2;
addressInDB.State = customerAddressViewModel.Address.State;
addressInDB.PostalCode = customerAddressViewModel.Address.PostalCode;
addressInDB.State = customerAddressViewModel.Address.State;
addressInDB.City = customerAddressViewModel.Address.City;
addressInDB.Country = customerAddressViewModel.Address.Country;
_context.SaveChanges();
return(RedirectToAction("AddressForm", "Customer"));
}
public ActionResult Save(CustomerAddress customerAddress)
{
if (!ModelState.IsValid)
{
var viewModel = new CustomerAddressViewModel
{
CustomerAddress = customerAddress,
AddressTypes = _context.AddressTypes.ToList()
};
return(View("CustomerAddressForm", viewModel));
}
if (customerAddress.Id == 0)
{
_context.CustomerAddress.Add(customerAddress);
}
else
{
var customerAddressInDb = _context.CustomerAddress.Single(m => m.Id == customerAddress.Id);
customerAddressInDb.AddressTypeId = customerAddress.AddressTypeId;
customerAddressInDb.StreetAddress = customerAddress.StreetAddress;
customerAddressInDb.Address2 = customerAddress.Address2;
customerAddressInDb.City = customerAddress.City;
customerAddressInDb.State = customerAddress.State;
customerAddressInDb.ZipCode = customerAddress.ZipCode;
}
_context.SaveChanges();
return(RedirectToAction("Details", "Customers", new { id = customerAddress.CustomerId }));
}
public PartialViewResult UpdateCustomerAddress(Int32 id)
{
SRLogRepository objdata = new SRLogRepository();
SR_Log_DatabaseSQLEntities db = new SR_Log_DatabaseSQLEntities();
tblCustAddress custaddress = db.tblCustAddresses.Where(x => x.Id == id).FirstOrDefault();
CustomerAddressViewModel address = new CustomerAddressViewModel();
address.Address1 = custaddress.Address1;
address.Address2 = custaddress.Address2;
address.City = custaddress.City;
address.State = custaddress.State;
address.ZipCode = custaddress.ZipCode;
address.Country = custaddress.Country;
address.SiteName = custaddress.SiteName;
if (custaddress.IsPrimaryAddress == true)
{
address.IsPrimaryAddress = true;
}
else
{
address.IsPrimaryAddress = false;
}
//address.IsPrimaryAddress = custaddress.IsPrimaryAddress;
address.ProjectManagerList = objdata.GetGroupUser();
address.ProjectManager = custaddress.ProjectManager;
address.Id = custaddress.Id;
address.CustomerId = custaddress.CustomerId;
ViewBag.Adddisable = false;
ViewBag.CustomerId = custaddress.CustomerId;
ViewBag.CustomerAddressId = custaddress.Id;
return(PartialView("CreateCustomerAddress", address));
}
protected override void OnAppearing()
{
base.OnAppearing();
AddressService.loaderCheck = true;
CustomerAddressViewModel model = new CustomerAddressViewModel();
addressList.BindingContext = model;
}
public async Task <IHttpActionResult> UpdateOrderCustomerInfo(CustomerAddressViewModel request)
{
var manager = new SpotGoodsManager();
var result = await manager.UpdateOrderCustomerInfo(request.SpotGoodsId, request.Address, request.CustomerPhone, request.CustomerName);
await manager.UpdateSpotGoodsStatus(request.SpotGoodsId, request.IsSF?SpotGoodsStatus.SF : SpotGoodsStatus.PickBySelf);
return(Ok(result));
}
public ActionResult UpdateCustomerAddress(CustomerAddressViewModel custaddress)
{
SR_Log_DatabaseSQLEntities db = new SR_Log_DatabaseSQLEntities();
if (custaddress.CustomerId != 0)
{
CustomerRepository objdata = new CustomerRepository();
if (string.IsNullOrEmpty(custaddress.Address1) == false)
{
custaddress.Address1 = custaddress.Address1.ToUpper();
}
if (string.IsNullOrEmpty(custaddress.Address2) == false)
{
custaddress.Address2 = custaddress.Address2.ToUpper();
}
if (string.IsNullOrEmpty(custaddress.City) == false)
{
custaddress.City = custaddress.City.ToUpper();
}
if (string.IsNullOrEmpty(custaddress.Country) == false)
{
custaddress.Country = custaddress.Country.ToUpper();
}
if (string.IsNullOrEmpty(custaddress.State) == false)
{
custaddress.State = custaddress.State.ToUpper();
}
if (string.IsNullOrEmpty(custaddress.ZipCode) == false)
{
custaddress.ZipCode = custaddress.ZipCode.ToUpper();
}
if (string.IsNullOrEmpty(custaddress.SiteName) == false)
{
custaddress.SiteName = custaddress.SiteName.ToUpper();
}
objdata.AddUpdateCustomerAddress(custaddress, "Update");
tblCustomer customer = db.tblCustomers.Where(x => x.CustomerId == custaddress.CustomerId).FirstOrDefault();
var act = new ActivityRepository();
act.AddActivityLog(Convert.ToString(Session["User"]), "Edit address", "UpdateCustomerAddress", "Addresses for customer " + customer.CustomerName.ToUpper() + " edited by " + Convert.ToString(Session["User"]) + ".");
}
//CustomerRepository _repository = new CustomerRepository();
//var cust = _repository.GetCustomerDetails(custaddress.CustomerId);
tblCustAddress cust = new tblCustAddress();
return(Json(cust, JsonRequestBehavior.AllowGet));
}
// GET: Customers/Create
public ActionResult Create()
{
CustomerAddressViewModel customerAddressViewModel = new CustomerAddressViewModel()
{
address = new Address(),
customer = new Customer(),
};
return(View(customerAddressViewModel));
}
public async Task <IActionResult> Edit(CustomerAddressViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
await this.addressService.EditAsync <CustomerAddressViewModel>(model);
return(this.Redirect($"/Customers/Edit/{model.CustomerId}"));
}
public PartialViewResult CreateCustomerAddress(int customerid)
{
CustomerAddressViewModel custaddress = new CustomerAddressViewModel();
SRLogRepository objdata = new SRLogRepository();
custaddress.CustomerId = customerid;
ViewBag.CustomerId = customerid;
ViewBag.CustomerAddressId = 0;
custaddress.IsPrimaryAddress = false;
custaddress.ProjectManagerList = objdata.GetGroupUser();
return(PartialView(custaddress));
}
public static CustomerAddress CustomerAddressMapper(CustomerAddressViewModel address)
{
return(new CustomerAddress
{
Country = address.Country,
City = address.City,
Address1 = address.Address1,
Address2 = address.Address2,
Email = address.Email,
CreatedOn = DateTime.UtcNow,
UpdatedOn = DateTime.UtcNow,
});
}
public ActionResult CustomerAddressForm(int customerId)
{
var viewModel = new CustomerAddressViewModel
{
CustomerAddress = new CustomerAddress()
{
CustomerId = customerId,
},
AddressTypes = _context.AddressTypes.ToList()
};
return(View("CustomerAddressForm", viewModel));
}
public async Task GetById_NotFoundTestAsync()
{
var customerId = CustomerMock.CustomerIdViewModelFaker.Generate();
CustomerAddressViewModel customer = null;
_customerServiceMock.Setup(x => x.GetAddressByIdAsync(It.IsAny <CustomerIdViewModel>()))
.ReturnsAsync(customer);
var response = await _httpClient.GetAsync($"/api/v1/customers/{customerId.Id}");
response.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
public ActionResult Create(CustomerAddressViewModel model)
{
if (ModelState.IsValid)
{
db.Addresses.Add(model.Address);
db.Customers.Add(model.Customer);
db.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
ViewBag.AddressID = new SelectList(db.Addresses, "ID", "Address1", model.Customer.AddressID);
return(View(model.Customer));
}
public static CustomerAddress MapCustomerAddress(CustomerAddressViewModel address)
{
return(new CustomerAddress
{
AddressLine1 = address.AddressLine1,
AddressLine2 = address.AddressLine2,
City = address.City,
State = address.State,
PostalCode = address.PostalCode,
Country = address.Country,
DateCreated = DateTime.UtcNow,
DateUpdated = DateTime.UtcNow,
});
}
//Maps a customeraddressVM to customeraddress data model
public static CustomerAddress MapCustomerAddress(CustomerAddressViewModel address)
{
return(new CustomerAddress
{
CreatedOn = address.CreatedOn,
UpdatedOn = address.UpdatedOn,
AddressLine1 = address.AddressLine1,
AddressLine2 = address.AddressLine2,
City = address.City,
State = address.State,
PostalCode = address.PostalCode,
Country = address.Country
});
}
// GET: Customer/Create
public ActionResult Create()
{
var viewModel = new CustomerAddressViewModel
{
Customer = new Customer(),
Address = new Address(),
Pickup = new Pickup(),
Day = new List <string> {
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"
}
};
return(View(viewModel));
}
public static CustomerAddress MapCustomerAddress(CustomerAddressViewModel addressViewModel)
{
return(new CustomerAddress
{
Id = addressViewModel.Id,
CreatedDate = addressViewModel.CreatedDate,
AddressLine1 = addressViewModel.AddressLine1,
AddressLine2 = addressViewModel.AddressLine2,
City = addressViewModel.City,
State = addressViewModel.State,
Country = addressViewModel.Country,
PostalCode = addressViewModel.PostalCode
});
}
public ActionResult Delete(int id)
{
var customerAddress = _context.CustomerAddress.Include(x => x.AddressType).SingleOrDefault(m => m.Id == id);
if (customerAddress == null)
{
return(HttpNotFound());
}
var viewModel = new CustomerAddressViewModel
{
CustomerAddressId = id,
CustomerAddress = customerAddress,
};
return(View(viewModel));
}
public ActionResult Edit(int id)
{
var customerAddress = _context.CustomerAddress.SingleOrDefault(c => c.Id == id);
if (customerAddress == null)
{
return(HttpNotFound());
}
var viewModel = new CustomerAddressViewModel
{
CustomerAddress = customerAddress,
AddressTypes = _context.AddressTypes.ToList()
};
return(View("CustomerAddressForm", viewModel));
}
public ActionResult AddAddress(CustomerAddressViewModel model)
{
if (ModelState.IsValid)
{
model.City = LocationWalker.GetCities().FirstOrDefault(f => f.Id == int.Parse(model.City)).Title;
var customerWorker = new CustomerWorker();
customerWorker.InsertSiteCustomerAddress(model);
return(RedirectToAction("Address"));
}
ViewBag.Cities = LocationWalker.GetCities().Select(s => new SelectListItem {
Value = s.Id.ToString(), Text = s.Title, Selected = s.Id == int.Parse(model.City)
});
ViewBag.Districts = LocationWalker.GetDistrict(1).Select(s => new SelectListItem {
Value = s.Title, Text = s.Title, Selected = s.Title == model.District
});
return(View(model));
}
public string GetAddressByAddress(string addressID)
{
try
{
CustomerAddressViewModel address = null;
if (!string.IsNullOrEmpty(addressID))
{
OperationsStatusViewModel operationsStatus = new OperationsStatusViewModel();
address = Mapper.Map <CustomerAddress, CustomerAddressViewModel>(_customerBusiness.GetAddressByAddress(int.Parse(addressID)));
}
return(JsonConvert.SerializeObject(new { Result = "OK", Record = address }));
}
catch (Exception ex)
{
return(JsonConvert.SerializeObject(new { Result = "ERROR", Message = ex.Message }));
}
}
public string DeleteCustomerAddress(CustomerAddressViewModel customerAddress)
{
OperationsStatusViewModel OperationsStatusViewModelObj = null;
if (!ModelState.IsValid)
{
try
{
OperationsStatusViewModelObj = Mapper.Map <OperationsStatus, OperationsStatusViewModel>(_customerBusiness.DeleteAddress(Mapper.Map <CustomerAddressViewModel, CustomerAddress>(customerAddress)));
}
catch (Exception ex)
{
return(JsonConvert.SerializeObject(new { Result = "ERROR", Message = ex.Message }));
}
}
return(JsonConvert.SerializeObject(new { Result = "OK", Record = OperationsStatusViewModelObj }));
}
// GET: /Manage/AddAddress
public ActionResult AddAddress()
{
var model = new CustomerAddressViewModel()
{
CustomerId = CustomerLayer.Customer.Id,
IsDefault = false,
Status = 1
};
ViewBag.Cities = LocationWalker.GetCities().Select(s => new SelectListItem {
Value = s.Id.ToString(), Text = s.Title
});
ViewBag.Districts = LocationWalker.GetDistrict(1).Select(s => new SelectListItem {
Value = s.Title, Text = s.Title
});
return(View(model));
}
// GET: Customers/Details/5
public ActionResult Details(int?id)
{
CustomerAddressViewModel customerAddressViewModel = new CustomerAddressViewModel();
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
customerAddressViewModel.customer = db.Customers.Find(id);
customerAddressViewModel.address = db.Addresses.Find(customerAddressViewModel.customer.AddressId);
customerAddressViewModel.PickUps = db.PickUps.Where(c => c.PickUpId == customerAddressViewModel.customer.PickId).Single();
if (customerAddressViewModel.customer == null)
{
return(HttpNotFound());
}
return(View(customerAddressViewModel));
}
